root/trunk/tango/scrapple/sys/win32/Registry.d

/*
 * Copyright (c) 2007 John Chapman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

/**
 * Provides classes for working with the Windows _registry.
 * modified by yidabu, 20070922
   under DMD 1.021, tango 0.99.1 RC4, WindosXP SP2
   example:
   
    import tango.io.Stdout;
    import Registry;

    void main()
    {
        char[] result;
        scope httpkey = RegistryKey.classesRoot.openSubKey(r"HTTP\shell\open\command");
        if(httpkey !is null)
        {
            result = httpkey.getValue!(string)(null);
            Stdout(result).newline;
            //"C:\Program Files\Internet Explorer\iexplore.exe" -nohome
        }
        else
            Stdout("failed").newline;
        
    }   
 
  
 */
//module juno.utils.registry;
module Registry;

/*
private import juno.base.core,
  juno.base.string,
  juno.base.environment,
  juno.base.numeric,
  juno.base.native,
  juno.io.core;
*/
private import tango.core.Exception;
private import tango.stdc.string : wcslen;
private import tango.text.convert.Utf : toString16, toUTF8 = toString;

// Grabbed from juno.base.native, use tango.sys.win32.UserGdi have some problem here
typedef void* Handle = null;
extern(Windows)
{
    extern final Handle INVALID_HANDLE_VALUE; // Already defined by Phobos
    struct OVERLAPPED {
      uint Internal;
      uint InternalHigh;
      union {
        struct {
          uint Offset;
          uint OffsetHigh;
        }
        void* Pointer;
      }
      Handle hEvent;
    }
    struct FILETIME {
      uint dwLowDateTime;
      uint dwHighDateTime;
    }
    struct SECURITY_ATTRIBUTES {
      uint nLength;
      void* lpSecurityDescriptor;
      int bInheritHandle;
    }
    enum : uint {
      REG_NONE                        = 0,
      REG_SZ                          = 1,
      REG_EXPAND_SZ                   = 2,
      REG_BINARY                      = 3,
      REG_DWORD                       = 4,
      REG_DWORD_LITTLE_ENDIAN         = 4,
      REG_DWORD_BIG_ENDIAN            = 5,
      REG_LINK                        = 6,
      REG_MULTI_SZ                    = 7,
      REG_RESOURCE_LIST               = 8,
      REG_FULL_RESOURCE_DESCRIPTOR    = 9,
      REG_RESOURCE_REQUIREMENTS_LIST  = 10,
      REG_QWORD                       = 11,
      REG_QWORD_LITTLE_ENDIAN         = 11
    }
    enum : uint {
      DELETE                          = 0x00010000,
      READ_CONTROL                    = 0x00020000,
      WRITE_DAC                       = 0x00040000,
      WRITE_OWNER                     = 0x00080000,
      SYNCHRONIZE                     = 0x00100000,
      STANDARD_RIGHTS_REQUIRED        = 0x000F0000,
      STANDARD_RIGHTS_READ            = READ_CONTROL,
      STANDARD_RIGHTS_WRITE           = READ_CONTROL,
      STANDARD_RIGHTS_EXECUTE         = READ_CONTROL,
      STANDARD_RIGHTS_ALL             = 0x001F0000,
      SPECIFIC_RIGHTS_ALL             = 0x0000FFFF
    }
    enum {
      ERROR_SUCCESS = 0,
      ERROR_INVALID_FUNCTION = 1,
      ERROR_FILE_NOT_FOUND = 2,
      ERROR_PATH_NOT_FOUND = 3,
      ERROR_TOO_MANY_OPEN_FILES = 4,
      ERROR_ACCESS_DENIED = 5,
      ERROR_INVALID_HANDLE = 6,
      ERROR_CLASS_ALREADY_EXISTS = 1410
    }

    enum : uint {
      KEY_QUERY_VALUE        = 0x0001,
      KEY_SET_VALUE          = 0x0002,
      KEY_CREATE_SUB_KEY     = 0x0004,
      KEY_ENUMERATE_SUB_KEYS = 0x0008,
      KEY_NOTIFY             = 0x0010,
      KEY_CREATE_LINK        = 0x0020,

      KEY_READ               = (STANDARD_RIGHTS_READ | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY) & ~SYNCHRONIZE,
      KEY_WRITE              = (STANDARD_RIGHTS_WRITE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY) & ~SYNCHRONIZE,
      KEY_EXECUTE            = KEY_READ & ~SYNCHRONIZE,
      KEY_ALL_ACCESS         = (STANDARD_RIGHTS_ALL | KEY_QUERY_VALUE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY | KEY_CREATE_LINK) & ~SYNCHRONIZE,
    }
    alias void function(uint dwErrorCode, uint dwNumberOfBytesTransferred, OVERLAPPED* lpOverlapped) OVERLAPPED_COMPLETION_ROUTINE;
    uint ExpandEnvironmentStringsW(wchar* lpSrc, wchar* lpDst, uint nSize);
    alias ExpandEnvironmentStringsW ExpandEnvironmentStrings;
    extern final Handle HKEY_CLASSES_ROOT;
    extern final Handle HKEY_CURRENT_USER;
    extern final Handle HKEY_LOCAL_MACHINE;
    extern final Handle HKEY_USERS;
    extern final Handle HKEY_PERFORMANCE_DATA;
    extern final Handle HKEY_CURRENT_CONFIG;
    extern final Handle HKEY_DYN_DATA;
    int ReadDirectoryChangesW(Handle hDirectory, void* lpBuffer, uint nBufferLength, int bWatchSubtree, uint dwNotifyFilter, ref uint lpBytesReturned, OVERLAPPED* lpOverlapped, OVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
    alias ReadDirectoryChangesW ReadDirectoryChanges;

    int RegOpenKeyExW(Handle hKey, wchar* lpSubKey, uint ulOptions, uint samDesired, out Handle phkResult);
    alias RegOpenKeyExW RegOpenKeyEx;

    int RegQueryValueExW(Handle hKey, wchar* lpValueName, uint* lpReserved, uint* lpType, ubyte* lpData, uint* lpcbData);
    alias RegQueryValueExW RegQueryValueEx;

    int RegQueryInfoKeyW(Handle hKey, wchar* lpClass, uint* lpcchClass, uint* lpReserved, uint* lpcSubKeys, uint* lpcbMaxSubKeyLen, uint* lpcbMaxClassLen, uint* lpcValues, uint* lpcbMaxValueNameLen, uint* lpcMaxValueLen, uint* lpcbSecurityDescriptor, FILETIME* lpftLastWriteTime);
    alias RegQueryInfoKeyW RegQueryInfoKey;

    int RegEnumKeyExW(Handle hKey, uint dwIndex, wchar* lpName, uint* lpcchName, uint* lpReserved, wchar* lpClass, uint* lpcchClass, FILETIME* lpftLastWriteTime);
    alias RegEnumKeyExW RegEnumKeyEx;

    int RegEnumValueW(Handle hKey, uint dwIndex, wchar* lpValueName, uint* lpcchValueName, uint* lpReserved, uint* lpType, ubyte* lpData, uint* lpcbData);
    alias RegEnumValueW RegEnumValue;

    int RegCreateKeyExW(Handle hKey, wchar* lpSubKey, uint Reserved, wchar* lpClass, uint dwOptions, int samDesired, SECURITY_ATTRIBUTES* lpSecurityAttriubtes, out Handle phkResult, out uint lpsdwDisposition);
    alias RegCreateKeyExW RegCreateKeyEx;

    int RegCloseKey(Handle hKey);

    int RegFlushKey(Handle hKey);

    int RegDeleteKeyW(Handle hKey, wchar* lpName);
    alias RegDeleteKeyW RegDeleteKey;

    int RegDeleteValueW(Handle hKey, wchar* lpValueName);
    alias RegDeleteValueW RegDeleteValue;

    int RegSetValueExW(Handle hKey, wchar* lpValueName, uint Reserved, uint dwType, ubyte* lpData, uint cbData);
    alias RegSetValueExW RegSetValueEx;
}//extern


/*
//for tango.sys.win32.UserGdi
alias RegQueryInfoKeyW RegQueryInfoKey;
alias RegSetValueExW RegSetValueEx;
alias RegUnLoadKeyW RegUnLoadKey;
alias RegRestoreKeyW RegRestoreKey;
alias RegSaveKeyW RegSaveKey;
alias RegSetValueW RegSetValue;
alias RegQueryValueW RegQueryValue;
alias RegQueryMultipleValuesW RegQueryMultipleValues;
alias RegQueryValueExW RegQueryValueEx;
alias RegReplaceKeyW RegReplaceKey;
alias RegConnectRegistryW RegConnectRegistry;
alias RegCreateKeyW RegCreateKey;
alias RegCreateKeyExW RegCreateKeyEx;
alias RegDeleteKeyW RegDeleteKey;
alias RegDeleteValueW RegDeleteValue;
alias RegEnumKeyW RegEnumKey;
alias RegEnumKeyExW RegEnumKeyEx;
alias RegEnumValueW RegEnumValue;
alias RegLoadKeyW RegLoadKey;
alias RegOpenKeyW RegOpenKey;
alias RegOpenKeyExW RegOpenKeyEx;
alias RegQueryInfoKeyW RegQueryInfoKey;
alias HANDLE Handle;
*/

alias char[] string;

// Grabbed from juno.base.string since Tango's stdc.stringz, text.convert.Utf lacks these:
public wchar* toString16z(string s, int start = 0, int count = -1) {
  if (s is null)
    return null;
  if (s.length == 0 || count == 0)
    return "";
  if (count == -1)
    count = s.length;
  return s[start .. count].toUTF16z();
}
public string toString(wchar* s, int start = 0, int count = -1) {
  if (s == null)
    return null;
  if (count == -1)
    count = wcslen(cast(dchar*)s);
  return s[start .. count].toUTF8();
}
/**
 * Returns a string array containing the substrings in s that are delimited by elements of the specified char array.
 * Params:
 *   s = The string to _split.
 *   separator = An array of characters that delimit the substrings in s.
 *   count = The maximum number of substrings to return.
 *   removeEmptyEntries = true to omit empty array elements from the array returned, or false to include empty array elements in the array returned.
 * Returns: An array whose elements contain the substrings in s that are delimited by one or more characters in separator.
 */
public string[] split(string s, char[] separator, int count = int.max, bool removeEmptyEntries = false) {

  int createSeparatorList(ref int[] sepList) {
    int foundCount;
    if (separator.length == 0) {
      for (int i = 0; i < s.length && foundCount < sepList.length; i++) {
        if (isWhiteSpace(s[i]))
          sepList[foundCount++] = i;
      }
    }
    else {
      for (int i = 0; i < s.length && foundCount < sepList.length; i++) {
        for (int j = 0; j < separator.length; j++) {
          if (s[i] == separator[j]) {
            sepList[foundCount++] = i;
            break;
          }
        }
      }
    }
    return foundCount;
  }

  if (count == 0 || (removeEmptyEntries && s.length == 0))
    return new string[0];

  int[] sepList = new int[s.length];
  int replaceCount = createSeparatorList(sepList);

  if (replaceCount == 0 || count == 1)
    return [ s ];

  string[] splitStrings;
  int arrayIndex, currentIndex;

  if (removeEmptyEntries) {
    int max = (replaceCount < count) ? replaceCount + 1 : count;
    splitStrings.length = max;
    for (int i = 0; i < replaceCount && currentIndex < s.length; i++) {
      if (sepList[i] - currentIndex > 0)
        splitStrings[arrayIndex++] = s[currentIndex .. sepList[i]];
      currentIndex = sepList[i] + 1;
      if (arrayIndex == count - 1) {
        while (i < replaceCount - 1 && currentIndex == sepList[++i]) {
          currentIndex += 1;
        }
        break;
      }
    }

    if (currentIndex < s.length)
      splitStrings[arrayIndex++] = s[currentIndex .. $];

    string[] strings = splitStrings;
    if (arrayIndex != max) {
      strings.length = arrayIndex;
      for (int j = 0; j < arrayIndex; j++)
        strings[j] = splitStrings[j];
    }
    splitStrings = strings;
  }
  else {
    count--;
    int max = (replaceCount < count) ? replaceCount : count;
    splitStrings.length = max + 1;
    for (int i = 0; i < max && currentIndex < s.length; i++) {
      splitStrings[arrayIndex++] = s[currentIndex .. sepList[i]];
      currentIndex = sepList[i] + 1;
    }

    if (currentIndex < s.length && max >= 0)
      splitStrings[arrayIndex] = s[currentIndex .. $];
    else if (arrayIndex == max)
      splitStrings[arrayIndex] = null;
  }

  return splitStrings;
}
private final char[] WhiteSpaceChars = [ '\t', '\n', '\v', '\f', '\r', ' ' ];

/**
 * Indicates whether the specified character is white space.
 * Params: c = A character.
 * Returns: true if c is white space; otherwise, false.
 */
public bool isWhiteSpace(char c) {
  foreach (ch; WhiteSpaceChars) {
    if (ch == c)
      return true;
  }
  return false;
}


    wchar* toUTF16z(char[] s)
    {
        wchar[] ws;
        ws = toString16(s);
        ws ~= '\0';
        return ws.ptr;
    }
    

public string expandEnvironmentVariables(string name) {
  string[] parts = name.split(['%']);

  int c = 100;
  wchar[] buffer = new wchar[c];
  for (int i = 1; i < parts.length - 1; i++) {
    if (parts[i].length > 0) {
      string temp = "%" ~ parts[i] ~ "%";
      uint n = ExpandEnvironmentStrings(temp.toString16z(), buffer.ptr, c);
      while (n > c) {
        c = n;
        buffer.length = c;
        n = ExpandEnvironmentStrings(temp.toString16z(), buffer.ptr, c);
      }
    }
  }
  int n = ExpandEnvironmentStrings(name.toString16z(), buffer.ptr, c);
  while (n > c) {
    c = n;
    buffer.length = c;
    n = ExpandEnvironmentStrings(name.toString16z(), buffer.ptr, c);
  }

  return .toString(buffer.ptr);
}


/**
 * Identifies the data type of a value in the registry.
 */
public enum RegistryValueKind {
  Unknown = 0,        /// Indicates an unsupported registry data type.
  String = 1,         /// Specifies a string. Equivalent to REG_SZ.
  ExpandString = 2,   /// Specifies a string containing references to environment variables. Equivalent to REG_EXPAND_SZ.
  Binary = 3,         /// Specifies binary data in any form. Equivalent to REG_BINARY.
  DWord = 4,          /// Specifies a 32-bit binary number. Equivalent to REG_DWORD.
  MultiString = 7,    /// Specifies an array of strings. Equivalent to REG_MULTI_SZ.
  QWord = 11          /// Specifies a 64-bit binary number. Equivalent to REG_QWORD.
}

/**
 * Represents a node in the Windows registry.
 */
public final class RegistryKey {

  private const string[] HKEY_NAMES = [ 
    "HKEY_CLASSES_ROOT", "HKEY_CURRENT_USER", "HKEY_LOCAL_MACHINE", "HKEY_USERS", "HKEY_PERFORMANCE_DATA", "HKEY_CURRENT_CONFIG", "HKEY_DYN_DATA"
  ];

  public static const RegistryKey classesRoot;      /// Defines the types of documents and properties associated with those types. Reads HKEY_CLASSES_ROOT.
  public static const RegistryKey currentUser;      /// Contains information about the current user preferences. Reads HKEY_CURRENT_USER.
  public static const RegistryKey localMachine;     /// Contains configuration data for the local machine. Reads HKEY_LOCAL_MACHINE.
  public static const RegistryKey users;            /// Contains information about the default user configuration. Reads HKEY_USERS.
  public static const RegistryKey performanceData;  /// Contains performance information for software components. Reads HKEY_PERFORMANCE_DATA.
  public static const RegistryKey currentConfig;    /// Contains configuration information about hardware that is not specifiec to the user. Reads HKEY_CURRENT_CONFIG.
  public static const RegistryKey dynData;          /// Contains dynamic registry data. Reads HKEY_DYN_DATA.

  private Handle hKey_;
  private string name_;
  private bool systemKey_;
  private bool perfDataKey_;
  private bool writable_;
  private bool remoteKey_;
  private bool dirty_;

  static this() {
    classesRoot = get(cast(Handle)HKEY_CLASSES_ROOT);
    currentUser = get(cast(Handle)HKEY_CURRENT_USER);
    localMachine = get(cast(Handle)HKEY_LOCAL_MACHINE);
    users = get(cast(Handle)HKEY_USERS);
    performanceData = get(cast(Handle)HKEY_PERFORMANCE_DATA);
    currentConfig = get(cast(Handle)HKEY_CURRENT_CONFIG);
    dynData = get(cast(Handle)HKEY_DYN_DATA);
  }

  ~this() {
    close();
  }

  /**
   * Retrieves a string representation of this key.
   * Returns: A string representing the key.
   */
  //public override string toString() {
  public string toString() {
    return name_;
  }

  /**
   * Closes the key.
   */
  public void close() {
    if (hKey_ != Handle.init) {
      if (!systemKey_) {
        RegCloseKey(hKey_);
        hKey_ = Handle.init;
      }
    }
  }

  /**
   * Writes all the attributes of this key to the registry.
   */
  public void flush() {
    if (hKey_ != Handle.init && dirty_)
      RegFlushKey(hKey_);
  }

  /**
   * Retrieves a subkey.
   * Params:
   *   name = Name or path of the subkey to open.
   *   writable = true if you need write access to the key.
   * Returns: The subkey requested, or null if the operation failed.
   */
  public RegistryKey openSubKey(string name, bool writable = false) {
    Handle hkey;
    int r = RegOpenKeyEx(hKey_, name.toString16z(), 0, (writable ? (KEY_READ | KEY_WRITE) : KEY_READ), hkey);
    if (r == ERROR_SUCCESS && hkey != Handle.init && hkey != INVALID_HANDLE_VALUE) {
      auto key = new RegistryKey(hkey, writable, false, false, false);
      key.name_ = this.name_ ~ '\\' ~ name;
      return key;
    }
    //if (r == ERROR_ACCESS_DENIED)
      //issueError(r, name_ ~ '\\' ~ name);
    return null;
  }

  public RegistryKey createSubKey(string name) {
    Handle hkey;
    uint disposition;
    int r = RegCreateKeyEx(hKey_, name.toString16z(), 0, null, 0, KEY_READ | KEY_WRITE, null, hkey, disposition);
    if (r == ERROR_SUCCESS && hkey != Handle.init && hkey != INVALID_HANDLE_VALUE) {
      auto key = new RegistryKey(hkey, true, false, false, false);
      if (name.length == 0)
        key.name_ = name_;
      else
        key.name_ = name_ ~ '\\' ~ name;
      return key;
    }
    //if (r != ERROR_SUCCESS)
      //issueError(r, name_ ~ '\\' ~ name);
    return null;
  }

  /**
   * Deletes the specified subkey.
   * Params: name = The _name of the subkey to delete.
   */
  public void deleteSubKey(string name) {
    RegDeleteKey(hKey_, name.toString16z());
  }

  public void deleteSubKeyTree(string name) {
    scope key = openSubKey(name, true);
    if (key !is null) {
      if (key.subKeyCount > 0) {
        foreach (subkey; key.subKeyNames)
          key.deleteSubKeyTree(subkey);
      }

      key.close();

      int r = RegDeleteKey(hKey_, name.toString16z());
      //if (r != ERROR_SUCCESS)
        //issueError(r, null);
    }
    else
      throw new RegistryException("Cannot delete a subkey tree because the subkey does not exist.");
  }

  /**
   * Deletes the specified value from the registry.
   * Params: name = The _name of the value to delete.
   */
  public void deleteValue(string name) {
    RegDeleteValue(hKey_, name.toString16z());
  }

  /**
   * Retrieves the registry data type of the value associated with the specified _name.
   * Params: name = The _name of the value whose registry data type is to be retrieved.
   * Returns: A value representing the registry data type of the value associated with name.
   */
  public RegistryValueKind getValueKind(string name) {
    uint cb, type;
    RegQueryValueEx(hKey_, name.toString16z(), null, &type, null, &cb);
    return cast(RegistryValueKind)type;
  }

  /**
   * Retrieves the value associated with the specified _name.
   * Params:
   *   name = The _name of the value to retrieve.
   *   defaultValue = The value to return if name does not exist.
   *   doNotExpand = Specify false to expand environment values.
   * Returns: The value associated with name, or defaultValue if name is not found.
   */
  public T getValue(T)(string name, T defaultValue = T.init, bool doNotExpand = false) {
    uint cb, type;
    if (RegQueryValueEx(hKey_, name.toString16z(), null, &type, null, &cb) == 0) {
      static if (is(T == int)) {
        if (type == REG_DWORD) {
          int b;
          RegQueryValueEx(hKey_, name.toString16z(), null, &type, cast(ubyte*)&b, &cb);
          return b;
        }
      }
      else static if (is(T == long)) {
        if (type == REG_QWORD) {
          long b;
          RegQueryValueEx(hKey_, name.toString16z(), null, &type, cast(ubyte*)&b, &cb);
          return b;
        }
      }
      else static if (is(T : string)) {
        if (type == REG_SZ || type == REG_EXPAND_SZ) {
          wchar[] b = new wchar[cb / 2];
          RegQueryValueEx(hKey_, name.toString16z(), null, &type, cast(ubyte*)b.ptr, &cb);
          string result = .toString(b.ptr);

          if (!doNotExpand && type == REG_EXPAND_SZ)
            return expandEnvironmentVariables(result);

          return result;
        }
      }
      else static if (is(T : string[])) {
        if (type == REG_MULTI_SZ) {
          string[] result;

          wchar[] b = new wchar[cb / 2];
          RegQueryValueEx(hKey_, name.toString16z(), null, &type, cast(ubyte*)b.ptr, &cb);

          uint index = 0;
          int end = b.length;
          while (index < end) {
            uint pos = index;
            while (pos < end && b[pos] != '\0') pos++;

            if (pos < end) {
              if (pos - index > 0) result ~= .toString(b.ptr, index, pos);
              else if (pos != end - 1) result ~= "";
            }
            else result ~= .toString(b.ptr, index, end);

            index = pos + 1;
          }

          return result;
        }
      }
      else static if (is(T == ubyte[])) {
        if (type == REG_BINARY || type == REG_DWORD_BIG_ENDIAN) {
          ubyte[] b = new ubyte[cb];
          RegQueryValueEx(hKey_, name.toString16z(), null, &type, b.ptr, &cb);
          return b;
        }
      }
    }
    return defaultValue;
  }

  /**
   * Sets the _value of a name/value pair in the registry key using the specified registry data type.
   * Params:
   *   name = The _name of the _value to be stored.
   *   value = The data to be stored.
   *   valueKind = The registry data type to use when storing the data.
   */
  public void setValue(T)(string name, T value, RegistryValueKind valueKind = RegistryValueKind.Unknown) {
    if (valueKind == RegistryValueKind.Unknown) {
      static if (is(T : string))
        valueKind = RegistryValueKind.String;
      else static if (is(T : string[]))
        valueKind = RegistryValueKind.MultiString;
      else static if (is(T == ubyte[]))
        valueKind = RegistryValueKind.Binary;
      else static if (is(T == int))
        valueKind = RegistryValueKind.DWord;
      else static if (is(T == long))
        valueKind = RegistryValueKind.QWord;
      else
        valueKind = RegistryValueKind.String;
    }

    int r = ERROR_SUCCESS;

    switch (valueKind) {
      case RegistryValueKind.String, RegistryValueKind.ExpandString:
        string s;
        static if (!is(T : string))
          s = .toString(value);
        else
          s = value;
        r = RegSetValueEx(hKey_, name.toString16z(), 0, REG_SZ, cast(ubyte*)s.toString16z(), (s.length * 2) + 2);
        break;
      case RegistryValueKind.MultiString:
        break;
      case RegistryValueKind.Binary:
        r = RegSetValueEx(hKey_, name.toString16z(), 0, REG_BINARY, cast(ubyte*)value.ptr, value.length);
        break;
      case RegistryValueKind.DWord:
        r = RegSetValueEx(hKey_, name.toString16z(), 0, REG_DWORD, cast(ubyte*)&value, int.sizeof);
        break;
      case RegistryValueKind.QWord:
        r = RegSetValueEx(hKey_, name.toString16z(), 0, REG_QWORD, cast(ubyte*)&value, long.sizeof);
        break;
      default:
    }

    if (r == ERROR_SUCCESS)
      dirty_ = true;
  }

  /**
   * Returns: The _name of the key.
   */
  public string name() {
    return name_;
  }

  /**
   * Retrieves the count of subkeys of this key.
   * Returns: The number of subkeys.
   */
  public int subKeyCount() {
    uint result;
    RegQueryInfoKey(hKey_, null, null, null, &result, null, null, null, null, null, null, null);
    return result;
  }

  /** 
   * Returns: An array of strings containing the subkey names.
   */
  public string[] subKeyNames() {
    int count = subKeyCount;
    string[] result = new string[count];

    if (count > 0) {
      wchar[256] buffer;
      for (int index = 0; index < count; index++) {
        uint cch = buffer.length;
        RegEnumKeyEx(hKey_, index, buffer.ptr, &cch, null, null, null, null);
        result[index] = .toString(buffer.ptr);
      }
    }

    return result;
  }

  /**
   * Retrieves the count of values in the key.
   * Returns: The number of values.
   */
  public int valueCount() {
    uint result;
    RegQueryInfoKey(hKey_, null, null, null, null, null, null, &result, null, null, null, null);
    return result;
  }

  /** 
   * Retrieves an array of strings containing the value names associated with this key.
   * Returns: An array of strings containing the value names.
   */
  public string[] valueNames() {
    int count = valueCount;
    string[] result = new string[count];

    if (count > 0) {
      wchar[256] buffer;
      for (int index = 0; index < count; index++) {
        uint cch = buffer.length;
        RegEnumValue(hKey_, index, buffer.ptr, &cch, null, null, null, null);
        result[index] = .toString(buffer.ptr);
      }
    }

    return result;
  }

  private this(Handle hKey, bool writable, bool systemKey = false, bool remoteKey = false, bool perfDataKey = false) {
    hKey_ = hKey;
    writable_ = writable;
    systemKey_ = systemKey;
    perfDataKey_ = perfDataKey;
  }

  private static RegistryKey get(Handle hKey) {
    auto key = new RegistryKey(hKey, true, true, false, hKey == HKEY_PERFORMANCE_DATA);
    key.name_ = HKEY_NAMES[cast(int)hKey & 0x0FFFFFFF];
    return key;
  }

  /*
  private void issueError(int errorCode, string s) {

    string getErrorMessage(uint error) {
      wchar[256] buffer;
      uint r = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_IGNORE_INSERTS, null, error, LOCALE_USER_DEFAULT, buffer.ptr, buffer.length + 1, null);
      if (r != 0) {
        return toString(buffer.ptr, 0, r);
      }
      return format("Unspecified error (0x{0:X8})", error);
    }

    switch (errorCode) {
      case ERROR_FILE_NOT_FOUND:
        throw new IOException("The specified registry key does not exist.");
      case ERROR_ACCESS_DENIED:
        throw new UnauthorizedAccessException("Access to the registry key '" ~ s ~ "' is denied.");
      default:
        throw new IOException(getErrorMessage(errorCode));
    }
    
  }
  */

}