RegistryKey (JRegistry)

java.lang.Object
- com.registry.RegistryKey

All Implemented Interfaces:

Serializable, Cloneable, Comparable<RegistryKey>
```
public class RegistryKey
extends Object
implements Cloneable, Comparable<RegistryKey>, Serializable
```
This is an abstract representation of a key in the Windows Registry. Each key is capable of holding named value-data pairs plus other subkeys in a tree like structure.
This class provides many different methods which allow for the creation and deletion of subkeys as well as the creation and deletion of values.

Also there are methods which can be used to query the different subkeys and values which can be found in a key as well as to test for the existence of keys and values. Methods are also provided which allow the registry key and its values to be renamed.
There are two different constructors available for use. One is generally used for when a key already exists in the registry, and the other can be used to create the key when the constructor is called.

Another way to create an instance of the RegistryKey class is through the parseKey methods. There are two versions of the method, one which returns a RegistryKey object if it already exists in the registry, and the other creates the key as the path is being parsed.
A final set of methods allow the keys to be saved to files, restored from files, and also to load and unload keys from a registry hive. These methods however require that the calling process have administrative priviledges, otherwise the methods fail with ERROR_ACCESS_DENIED.
Changes to the registry can be tracked using the RegistryListener and RegistryWatcher classes.
NOTE: On some Windows operating systems, the class name parameter may be ignored.
The allowance of this parameter is in order to make the library more complete.
A warning for users who might use the normal deleteKey() method to delete symbolic link keys, if that method is used you run the risk of also deleting the key that the link is pointing to. The deleteLink() method should be used instead.

Version:

1.8

Author:

Yinon Michaeli

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALL_FILTERS` Constant for `RegistryWatcher` combining all of the possible filters.
`static int`	`DEFAULT_FILTER` Constant for `RegistryWatcher` to notify caller if a subkey is added or deleted or if a value of the key changed.
`static String`	`DEFAULT_VALUE_NAME` Constant that represents the name of the default value.
`static int`	`ERROR_ACCESS_DENIED`
`static int`	`ERROR_ALREADY_EXISTS`
`static int`	`ERROR_BADDB`
`static int`	`ERROR_BADKEY`
`static int`	`ERROR_CANTOPEN`
`static int`	`ERROR_CANTREAD`
`static int`	`ERROR_CANTWRITE`
`static int`	`ERROR_CHILD_MUST_BE_VOLATILE`
`static int`	`ERROR_CODE` A constant to retrieve the error code from the array returned by `getKeyInfo()`.
`static int`	`ERROR_FILE_NOT_FOUND`
`static int`	`ERROR_FILENAME_EXCED_RANGE`
`static int`	`ERROR_INVALID_HANDLE`
`static int`	`ERROR_INVALID_PARAMETER`
`static int`	`ERROR_KEY_DELETED`
`static int`	`ERROR_KEY_HAS_CHILDREN`
`static int`	`ERROR_NO_LOG_SPACE`
`static int`	`ERROR_NO_SYSTEM_RESOURCES`
`static int`	`ERROR_NOT_REGISTRY_FILE`
`static int`	`ERROR_OUTOFMEMORY`
`static int`	`ERROR_PROC_NOT_FOUND`
`static int`	`ERROR_REGISTRY_CORRUPT`
`static int`	`ERROR_REGISTRY_IO_FAILED`
`static int`	`ERROR_SUCCESS`
`static int`	`HKEY_CLASSES_ROOT_INDEX` The index in the `listRoots()` array for the HKEY_CLASSES_ROOT registry key.
`static int`	`HKEY_CURRENT_CONFIG_INDEX` The index in the `listRoots()` array for the HKEY_CURRENT_CONFIG registry key.
`static int`	`HKEY_CURRENT_USER_INDEX` The index in the `listRoots()` array for the HKEY_CURRENT_USER registry key.
`static int`	`HKEY_DYN_DATA_INDEX` The index in the `listRoots()` array for the HKEY_DYN_DATA registry key.
`static int`	`HKEY_LOCAL_MACHINE_INDEX` The index in the `listRoots()` array for the HKEY_LOCAL_MACHINE registry key.
`static int`	`HKEY_PERFORMANCE_DATA_INDEX` The index in the `listRoots()` array for the HKEY_PERFORMANCE_DATA registry key.
`static int`	`HKEY_USERS_INDEX` The index in the `listRoots()` array for the HKEY_USERS registry key.
`static int`	`MAX_CHARACTER_LENGTH`
`static int`	`MAX_CLASS_LENGTH` A constant to retrieve the maximum length of a subkey's class name from the array returned by `getKeyInfo()`.
`static int`	`MAX_KEY_LENGTH`
`static int`	`MAX_SUB_KEY_LENGTH` A constant to retrieve the maximum length of a subkey name from the array returned by `getKeyInfo()`.
`static int`	`MAX_VALUE_LENGTH` A constant to retrieve the maximum length of a value's data from the array returned by `getKeyInfo()`.
`static int`	`MAX_VALUE_NAME_LENGTH` A constant to retrieve the maximum length of a value's name from the array returned by `getKeyInfo()`.
`static int`	`NUM_SUB_KEYS` A constant to retrieve the number of subkeys from the array returned by `getKeyInfo()`.
`static int`	`NUM_VALUES` A constant to retrieve the number of values from the array returned by `getKeyInfo()`.
`static String`	`OLD_COPY_TREE` System property for using the old copy tree method instead of the new version.
`static String`	`OLD_DELETE_TREE` System property for using the old delete tree method instead of the new version.
`static int`	`REG_NOTIFY_CHANGE_ATTRIBUTES` Constant for `RegistryWatcher` to notify caller of changes to the attributes of the key, such as the security descriptor information.
`static int`	`REG_NOTIFY_CHANGE_LAST_SET` Constant for `RegistryWatcher` to notify caller of changes to a value of the key.
`static int`	`REG_NOTIFY_CHANGE_NAME` Constant for `RegistryWatcher` to notify caller if a subkey is added or deleted.
`static int`	`REG_NOTIFY_CHANGE_SECURITY` Constant for `RegistryWatcher` to notify caller of changes to the security descriptor of the key.

Constructor Summary

Constructors
Constructor and Description
`RegistryKey(RegistryKey root, String subKey)` Constructs a new `RegistryKey` rooted at `root` which goes all the way to `subKey`.
`RegistryKey(RegistryKey root, String subKey, boolean create)` Constructs a new `RegistryKey` rooted at `root` which goes all the way to `subKey`.
`RegistryKey(RegistryKey root, String subKey, boolean create, boolean nonVolatile)` Constructs a new `RegistryKey` rooted at `root` which goes all the way to `subKey`.
`RegistryKey(RegistryKey root, String subKey, boolean create, String clazz)` Constructs a new `RegistryKey` rooted at `root` which goes all the way to `subKey` with a specific class name.
`RegistryKey(RegistryKey root, String subKey, boolean create, String clazz, boolean nonVolatile)` Constructs a new `RegistryKey` rooted at `root` which goes all the way to `subKey` with a specific class name.
`RegistryKey(String subKey)` Constructs a new `RegistryKey` rooted at HKEY_CURRENT_USER which goes all the way to `subKey`.
`RegistryKey(String subKey, boolean create)` Constructs a new `RegistryKey` rooted at HKEY_CURRENT_USER which goes all the way to `subKey`.
`RegistryKey(String subKey, boolean create, boolean nonVolatile)` Constructs a new `RegistryKey` rooted at HKEY_CURRENT_USER which goes all the way to `subKey`.
`RegistryKey(String subKey, boolean create, String clazz)` Constructs a new `RegistryKey` rooted at HKEY_CURRENT_USER which goes all the way to `subKey` with a specific class name.
`RegistryKey(String subKey, boolean create, String clazz, boolean nonVolatile)` Constructs a new `RegistryKey` rooted at HKEY_CURRENT_USER which goes all the way to `subKey` with a specific class name.

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`autoExpandEnvironmentVariables(boolean auto)` Specifies whether values of type REG_EXPAND_SZ should have their values expanded when returned from a call to `getValue(String)` or `getValues()`.
`boolean`	`canDelete()` Tests to see if `this` can be deleted.
`boolean`	`canDeleteLink()` Tests to see if `this` can be deleted.
`boolean`	`canDeleteTree()` Tests to see if the subtree rooted at `this` can be deleted.
`boolean`	`canLoadKey()` Tests to see if `this` can load a registry hive.
`boolean`	`canRename()` Tests to see if `this` can be renamed.
`boolean`	`canUnLoadKey()` Tests to see if `this` can be unloaded from the registry.
`boolean`	`canWrite()` Tests to see if values can be added to `this`.
`Object`	`clone()` Creates a shallow copy of `this`.
`int`	`compareTo(RegistryKey o)` Implements the compareTo method in the interface `Comparable`.
`static RegistryKey`	`connect(String machine, RegistryKey root)` Connects to a remote registry on the computer named by `machine`.
`void`	`copy(RegistryKey to)` Deprecated.
`int`	`copySubKeyValue(String subKey, RegistryKey dest, RegistryValue value)` Copies the registry value represented by `value` within `subKey` to the registry key `dest`.
`int`	`copySubKeyValues(String subKey, RegistryKey dest, RegistryValue... va)` Copies the set of registry values represented by `va` within `subKey` to the registry key `dest`.
`int`	`copySubKeyValues(String subKey, RegistryKey dest, String... va)` Copies the set of registry values named by `va` within `subKey` to the registry key `dest`.
`int`	`copySubTree(String subKey, RegistryKey dest)` Copies all of the subkeys and values from `subkey` to `dest`.
`int`	`copySubTree(String subKey, RegistryKey dest, boolean copyLinks)` Copies all of the subkeys and values from `subkey` to `dest`.
`int`	`copyTree(RegistryKey dest)` Copies all of the subkeys and values from `this` to `dest`.
`int`	`copyTree(RegistryKey dest, boolean copyLinks)` Copies all of the subkeys and values from `this` to `dest`.
`int`	`copyValue(RegistryKey dest, RegistryValue value)` Copies the registry value represented by `value` to the registry key `dest`.
`int`	`copyValues(RegistryKey dest, RegistryValue... va)` Copies the set of registry values represented by `va` to the registry key `dest`.
`int`	`copyValues(RegistryKey dest, String... va)` Copies the set of registry values named by `va` to the registry key `dest`.
`int`	`create()` Creates the key represented by `this` in the registry.
`int`	`create(boolean nonVolatile)` Creates the key represented by `this` in the registry.
`int`	`create(String clazz)` Creates the key represented by `this` in the registry with the specified class name.
`int`	`create(String clazz, boolean nonVolatile)` Creates the key represented by `this` in the registry with the specified class name.
`boolean`	`created()` Retrieves whether or not `this` was created or if it already existed in the registry.
`int`	`createLink(RegistryKey target)` Creates the key represented by `this` in the registry as a link to another key.
`int`	`createLink(RegistryKey target, boolean nonVolatile)` Creates the key represented by `this` in the registry as a link to another key.
`int`	`createLink(RegistryKey target, String clazz)` Creates the key represented by `this` in the registry with the specified class name as a link to another key.
`int`	`createLink(RegistryKey target, String clazz, boolean nonVolatile)` Creates the key represented by `this` in the registry with the specified class name as a link to another key.
`RegistryKey`	`createSubKey(String subKey)` Creates a new subkey under `this`.
`RegistryKey`	`createSubKey(String subKey, boolean nonVolatile)` Creates a new subkey under `this`.
`RegistryKey`	`createSubKey(String subKey, String clazz)` Creates a new subkey under `this` with the specified class name.
`RegistryKey`	`createSubKey(String subKey, String clazz, boolean nonVolatile)` Creates a new subkey under `this` with the specified class name.
`RegistryKey`	`createSubKeyLink(String subKey, RegistryKey target)` Creates a new subkey under `this` which will link to another key.
`RegistryKey`	`createSubKeyLink(String subKey, RegistryKey target, boolean nonVolatile)` Creates a new subkey under `this` which will link to another key.
`RegistryKey`	`createSubKeyLink(String subKey, RegistryKey target, String clazz)` Creates a new subkey under `this` with the specified class name as a link to another key.
`RegistryKey`	`createSubKeyLink(String subKey, RegistryKey target, String clazz, boolean nonVolatile)` Creates a new subkey under `this` with the specified class name as a link to another key.
`int`	`deleteKey()` Deletes `this` from the registry.
`static int`	`deleteKeys(RegistryKey... keys)` Deletes a set of registry keys from the registry.
`int`	`deleteLink()` Deletes `this` symbolic link from the registry.
`static int`	`deleteLinks(RegistryKey... keys)` Deletes a set of symbolic link registry keys from the registry.
`int`	`deleteSubKey(String subKey)` Deletes `subKey` from `this`.
`int`	`deleteSubKeys(String... subKeys)` Deletes the `subKey`s from `this`.
`int`	`deleteSubKeyValue(String subKey, RegistryValue value)` Deletes a named value represented by `value` from `subKey`.
`int`	`deleteSubKeyValue(String subKey, String value)` Deletes a named value from `subKey`.
`int`	`deleteSubKeyValues(String subKey, RegistryValue... va)` Deletes a set of named values represented by `va` from `subKey`.
`int`	`deleteSubKeyValues(String subKey, String... va)` Deletes a set of named values within `va` from `subKey`.
`int`	`deleteSubTree(String subKey)` Deletes the entire subtree rooted at `subKey` from the registry. This method uses the Windows Vista implementation for deleting a subtree.
`int`	`deleteSubTree(String subKey, boolean delLinks)` Deletes the entire subtree rooted at `subKey` from the registry. This method uses the Windows Vista implementation for deleting a subtree.
`int`	`deleteTree()` Deletes the entire subtree rooted at `this` from the registry.
`int`	`deleteTree(boolean delLinks)` Deletes the entire subtree rooted at `this` from the registry.
`int`	`deleteValue(RegistryValue value)` Deletes a named value represented by `value` from `this`.
`int`	`deleteValue(String value)` Deletes a named value from `this`.
`int`	`deleteValues(RegistryValue... va)` Deletes a set of named values represented by `RegistryValues` within `va` from `this`.
`int`	`deleteValues(String... va)` Deletes a set of named values within `va` from `this`.
`int`	`deleteView64Key(String subKey)` Deletes `subKey` from a 64-bit specific view of the registry from `this` if `isViewing64BitRegistry()` is `true`.
`int`	`deleteView64Keys(String... subKeys)` Deletes the `subKey`s from a 64-bit specific view of the registry from `this` if `isViewing64BitRegistry()` is `true`.
`int`	`disableReflection()` Disables registry reflection for `this` key.
`int`	`disableReflectionTree()` Disables registry reflection for `this` key and its entire subtree.
`int`	`enableReflection()` Enables registry reflection for `this` key.
`int`	`enableReflectionTree()` Enables registry reflection for `this` key and its entire subtree.
`boolean`	`equals(Object o)` Tests for equality with another `Object`.
`boolean`	`exists()` Tests to see if `this` exists in the registry.
`static String`	`expandEnvironmentVariables(String envStr)` Allows data from values of REG_EXPAND_SZ to be expanded.
`int`	`flushKey()` Writes all attributes of `this` into the registry.
`static String`	`formatErrorMessage(int code)` Retrieves the description for an error code that was returned by a method in the `RegistryKey` class or one of the `RegistryValue` classes.
`String`	`getClassName()` Retrieves the class name for `this` if it is set.
`static String`	`getCurrentUserSid()` Retrieves the current user's SID in `String` format.
`int`	`getIndex()` Retrieves the index of `this` under the parent.
`int[]`	`getKeyInfo()` Retrieves information about `this`.
`int`	`getLastError()` Retrieves the error code from the last open operation on `this`.
`int`	`getLevel()` Retrieves the level in the registry that `this` resides in.
`RegistryKey`	`getLinkLocation()` Retrieves the `RegistryKey` that `this` is linked to or `null` if `this` is not a link.
`String`	`getName()` Used to retrieve the name of `this` key.
`int`	`getNumberOfSubKeys()` Retrieves the number of subkeys that are under `this`.
`int`	`getNumberOfValues()` Retrieves the number of values that are in `this`.
`RegistryKey`	`getParent()` Retrieves the parent `RegistryKey` of `this`.
`String`	`getPath()` Retrieves the path in the registry which points to `this`.
`static RegistryQuota`	`getRegistryQuota()` Retrieves the current size of the registry and the maximum size that the registry is allowed to attain on the system.
`int`	`getRootIndex()` Retrieves the index of the root key of `this` in the `listRoots()` array.
`RegistryKey`	`getRootKey()` Retrieves the root key for `this`.
`static RegistryKey`	`getRootKeyForIndex(int index)` Retrieves the root key based on the HKEY_*_INDEX values.
`RegistryKey`	`getSubKey(String name)` Retrieves a `RegistryKey` which represents the subkey with a name of `name` under `this`.
`String[]`	`getSubKeyNames()` Retrieves a sorted array of `String`s which are the names of the subkeys under `this`.
`List<RegistryKey>`	`getSubKeys()` Retrieves a list of `RegistryKey`s which represent the subkeys that are under `this`.
`List<RegistryKey>`	`getSubKeys(String... subKeys)` Retrieves a list of `RegistryKey`s which are specified by the names in `subKeys` that are under `this`.
`SystemTime`	`getSystemTime()` Retrieves the last write time of `this` as a `SystemTime` object.
`RegistryValue`	`getValue(String name)` Retrieves a `RegistryValue` which represents the value with a name of `name` under `this`.
`String[]`	`getValueNames()` Retrieves a sorted array of `String`s which are the names of the values under `this`.
`List<RegistryValue>`	`getValues()` Retrieves a list of `RegistryValue`s which represent the values that are under `this`.
`List<RegistryValue>`	`getValues(String... va)` Retrieves a list of `RegistryValue`s which represent the values that are named by `va`.
`static ValueType`	`getValueType(int type)` Convenience method to retrieve the `ValueType` object based on the integer type that is passed in.
`boolean`	`hasDefaultValue()` Convenience method to test to see if `this` contains the default or unnamed value.
`int`	`hashCode()` Calculates the hash code value for `this`.
`boolean`	`hasSubKeys()` Convenience method to test to see if `this` contains any subkeys.
`boolean`	`hasValues()` Convenience method to test to see if `this` contains any values.
`static boolean`	`isAutoExpandEnvironmentVariables()` Determines whether values of type REG_EXPAND_SZ have their values automatically expanded when returned from a call to `getValue(String)` or `getValues()`.
`boolean`	`isLinkKey()` Checks to see whether `this` key is a symbolic link to another key.
`boolean`	`isRemoteRegistryKey()` Checks to see whether `this` key is a remote registry key.
`boolean`	`isViewing64BitRegistry()` Determines if the key is viewing the 64-bit registry or the 32-bit registry.
`boolean`	`keyExists(String subKey)` Tests to see if the specified subkey exists under `this`.
`boolean`	`keyIsLink(String subKey)` Tests to see if the specified subkey under `this` is a link.
`long`	`lastModified()` Returns the time that the key denoted by `this` was last modified.
`static RegistryKey[]`	`listRoots()` Retrieves an array of all the registry root keys.
`int`	`loadKey(String subKey, File regFile)` Creates a subkey under HKEY_USERS or HKEY_LOCAL_MACHINE and loads the data from the specified registry hive into that subkey.
`RegistryValue`	`newValue(String name, int type)` Creates a new value under `this` with the specified name and type.
`RegistryValue`	`newValue(String name, ValueType type)` Creates a new value under `this` with the specified name and type.
`static RegistryKey`	`parseKey(String key)` Tranforms the `String` path of a registry key into a `RegistryKey` object.
`static RegistryKey`	`parseKey(String key, boolean create)` Tranforms the `String` path of a registry key into a `RegistryKey` object.
`static RegistryKey`	`parseKey(String key, boolean create, boolean nonVolatile)` Tranforms the `String` path of a registry key into a `RegistryKey` object.
`boolean`	`queryReflection()` Determines whether registry reflection for `this` key is turned off.
`boolean`	`renameKey(String newKeyName)` Renames `this` to `newKeyName`.
`boolean`	`renameValue(RegistryValue old, String newValueName)` Renames the value specified by `old` to `newValueName`.
`boolean`	`renameValue(String old, String newValueName)` Renames the value specified by the name `old` to `newValueName`.
`int`	`replaceKey(File newRegFile, File oldRegFile)` Replaces the file backing `this` key and all the subkeys with another file, so that when the system is next started, the key and subkeys will have the values stored in the new file.
`int`	`replaceSubKey(String subKey, File newRegFile, File oldRegFile)` Replaces the file backing the subkey of `this` key and all its subkeys with another file, so that when the system is next started, the key and subkeys will have the values stored in the new file.
`int`	`restoreKey(File regFile)` Reads the registry information in a specified file and copies it over `this` key.
`int`	`restoreKey(File regFile, boolean force)` Reads the registry information in a specified file and copies it over `this` key.
`int`	`saveKey(boolean latest, boolean noCompress, File regFile)` Saves `this` and all subkeys and values to a new file, in the specified format.
`int`	`saveKey(File regFile)` Saves `this` and all subkeys and values to a new file, in the standard format.
`int`	`searchBinaryValue(int startIndex, byte[] value)` Allows `this` key's binary values (REG_NONE, REG_BINARY, etc.) to be searched for a particular value.
`int`	`searchIntegerValue(int startIndex, long value)` Allows `this` key's integer values (REG_DWORD and REG_QWORD, etc.) to be searched for a particular value.
`int`	`searchStringValue(int startIndex, boolean valueName, boolean data, boolean matchStr, String key)` Allows `this` key's string values (REG_SZ, REG_EXPAND_SZ and REG_MULTI_SZ) to be searched for a particular value.
`int`	`searchStringValue(int startIndex, String key)` Allows `this` key's string values (REG_SZ, REG_EXPAND_SZ and REG_MULTI_SZ) to be searched for a particular value.
`boolean`	`setLinkTo(RegistryKey target)` If `this` represents a symbolic link, then the target for `this` will be changed to the key represented by `target`.
`Iterator<String>`	`subKeyNamesIterator()` Retrieves an `Iterator` of `String`s which represent the names of the subkeys that are under `this`.
`Iterator<RegistryKey>`	`subKeysIterator()` Retrieves an `Iterator` of `RegistryKey`s which represent the subkeys that are under `this`.
`String`	`toNativePath()` Retrieves the `String` representation of `this` using the native registry api format.
`String`	`toString()` Retrieve a `String` representation of `this`.
`int`	`unLoadKey()` Unloads `this` and all subkeys and values from the registry.
`boolean`	`valueExists(String value)` Tests to see if the specified value exists under `this`.
`Iterator<String>`	`valueNamesIterator()` Retrieves an `Iterator` of `String`s which represent the names of the values that are under `this`.
`Iterator<RegistryValue>`	`valuesIterator()` Retrieves an `Iterator` of `RegistryValue`s which represent the values that are under `this`.
`void`	`view64BitRegistry(boolean view64)` Specifies whether the key should look into the 64-bit registry or the 32-bit registry This method does nothing on Windows 2000 systems.

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ERROR_CODE
```
public static final int ERROR_CODE
```
    A constant to retrieve the error code from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - NUM_SUB_KEYS
```
public static final int NUM_SUB_KEYS
```
    A constant to retrieve the number of subkeys from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - MAX_SUB_KEY_LENGTH
```
public static final int MAX_SUB_KEY_LENGTH
```
    A constant to retrieve the maximum length of a subkey name from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - MAX_CLASS_LENGTH
```
public static final int MAX_CLASS_LENGTH
```
    A constant to retrieve the maximum length of a subkey's class name from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - NUM_VALUES
```
public static final int NUM_VALUES
```
    A constant to retrieve the number of values from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - MAX_VALUE_NAME_LENGTH
```
public static final int MAX_VALUE_NAME_LENGTH
```
    A constant to retrieve the maximum length of a value's name from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - MAX_VALUE_LENGTH
```
public static final int MAX_VALUE_LENGTH
```
    A constant to retrieve the maximum length of a value's data from the array returned by getKeyInfo().
    
    See Also:
    Constant Field Values
  - ERROR_SUCCESS
```
public static final int ERROR_SUCCESS
```
    See Also:
    Constant Field Values
  - ERROR_FILE_NOT_FOUND
```
public static final int ERROR_FILE_NOT_FOUND
```
    See Also:
    Constant Field Values
  - ERROR_ACCESS_DENIED
```
public static final int ERROR_ACCESS_DENIED
```
    See Also:
    Constant Field Values
  - ERROR_INVALID_HANDLE
```
public static final int ERROR_INVALID_HANDLE
```
    See Also:
    Constant Field Values
  - ERROR_OUTOFMEMORY
```
public static final int ERROR_OUTOFMEMORY
```
    See Also:
    Constant Field Values
  - ERROR_INVALID_PARAMETER
```
public static final int ERROR_INVALID_PARAMETER
```
    See Also:
    Constant Field Values
  - ERROR_PROC_NOT_FOUND
```
public static final int ERROR_PROC_NOT_FOUND
```
    See Also:
    Constant Field Values
  - ERROR_ALREADY_EXISTS
```
public static final int ERROR_ALREADY_EXISTS
```
    See Also:
    Constant Field Values
  - ERROR_FILENAME_EXCED_RANGE
```
public static final int ERROR_FILENAME_EXCED_RANGE
```
    See Also:
    Constant Field Values
  - ERROR_BADDB
```
public static final int ERROR_BADDB
```
    See Also:
    Constant Field Values
  - ERROR_BADKEY
```
public static final int ERROR_BADKEY
```
    See Also:
    Constant Field Values
  - ERROR_CANTOPEN
```
public static final int ERROR_CANTOPEN
```
    See Also:
    Constant Field Values
  - ERROR_CANTREAD
```
public static final int ERROR_CANTREAD
```
    See Also:
    Constant Field Values
  - ERROR_CANTWRITE
```
public static final int ERROR_CANTWRITE
```
    See Also:
    Constant Field Values
  - ERROR_REGISTRY_CORRUPT
```
public static final int ERROR_REGISTRY_CORRUPT
```
    See Also:
    Constant Field Values
  - ERROR_REGISTRY_IO_FAILED
```
public static final int ERROR_REGISTRY_IO_FAILED
```
    See Also:
    Constant Field Values
  - ERROR_NOT_REGISTRY_FILE
```
public static final int ERROR_NOT_REGISTRY_FILE
```
    See Also:
    Constant Field Values
  - ERROR_KEY_DELETED
```
public static final int ERROR_KEY_DELETED
```
    See Also:
    Constant Field Values
  - ERROR_NO_LOG_SPACE
```
public static final int ERROR_NO_LOG_SPACE
```
    See Also:
    Constant Field Values
  - ERROR_KEY_HAS_CHILDREN
```
public static final int ERROR_KEY_HAS_CHILDREN
```
    See Also:
    Constant Field Values
  - ERROR_CHILD_MUST_BE_VOLATILE
```
public static final int ERROR_CHILD_MUST_BE_VOLATILE
```
    See Also:
    Constant Field Values
  - ERROR_NO_SYSTEM_RESOURCES
```
public static final int ERROR_NO_SYSTEM_RESOURCES
```
    See Also:
    Constant Field Values
  - MAX_KEY_LENGTH
```
public static final int MAX_KEY_LENGTH
```
    See Also:
    Constant Field Values
  - MAX_CHARACTER_LENGTH
```
public static final int MAX_CHARACTER_LENGTH
```
    See Also:
    Constant Field Values
  - REG_NOTIFY_CHANGE_NAME
```
public static final int REG_NOTIFY_CHANGE_NAME
```
    Constant for RegistryWatcher to notify caller if a subkey is added or deleted.
    
    See Also:
    Constant Field Values
  - REG_NOTIFY_CHANGE_ATTRIBUTES
```
public static final int REG_NOTIFY_CHANGE_ATTRIBUTES
```
    Constant for RegistryWatcher to notify caller of changes to the attributes of the key, such as the security descriptor information.
    
    See Also:
    Constant Field Values
  - REG_NOTIFY_CHANGE_LAST_SET
```
public static final int REG_NOTIFY_CHANGE_LAST_SET
```
    Constant for RegistryWatcher to notify caller of changes to a value of the key. This can include adding or deleting a value, or changing an existing value.
    
    See Also:
    Constant Field Values
  - REG_NOTIFY_CHANGE_SECURITY
```
public static final int REG_NOTIFY_CHANGE_SECURITY
```
    Constant for RegistryWatcher to notify caller of changes to the security descriptor of the key.
    
    See Also:
    Constant Field Values
  - DEFAULT_FILTER
```
public static final int DEFAULT_FILTER
```
    Constant for RegistryWatcher to notify caller if a subkey is added or deleted or if a value of the key changed.
    
    See Also:
    Constant Field Values
  - ALL_FILTERS
```
public static final int ALL_FILTERS
```
    Constant for RegistryWatcher combining all of the possible filters.
    
    See Also:
    Constant Field Values
  - DEFAULT_VALUE_NAME
```
public static final String DEFAULT_VALUE_NAME
```
    Constant that represents the name of the default value.
    
    See Also:
    Constant Field Values
  - HKEY_CLASSES_ROOT_INDEX
```
public static final int HKEY_CLASSES_ROOT_INDEX
```
    The index in the listRoots() array for the HKEY_CLASSES_ROOT registry key.
    
    See Also:
    Constant Field Values
  - HKEY_CURRENT_USER_INDEX
```
public static final int HKEY_CURRENT_USER_INDEX
```
    The index in the listRoots() array for the HKEY_CURRENT_USER registry key.
    
    See Also:
    Constant Field Values
  - HKEY_LOCAL_MACHINE_INDEX
```
public static final int HKEY_LOCAL_MACHINE_INDEX
```
    The index in the listRoots() array for the HKEY_LOCAL_MACHINE registry key.
    
    See Also:
    Constant Field Values
  - HKEY_USERS_INDEX
```
public static final int HKEY_USERS_INDEX
```
    The index in the listRoots() array for the HKEY_USERS registry key.
    
    See Also:
    Constant Field Values
  - HKEY_PERFORMANCE_DATA_INDEX
```
public static final int HKEY_PERFORMANCE_DATA_INDEX
```
    The index in the listRoots() array for the HKEY_PERFORMANCE_DATA registry key.
    
    See Also:
    Constant Field Values
  - HKEY_CURRENT_CONFIG_INDEX
```
public static final int HKEY_CURRENT_CONFIG_INDEX
```
    The index in the listRoots() array for the HKEY_CURRENT_CONFIG registry key.
    
    See Also:
    Constant Field Values
  - HKEY_DYN_DATA_INDEX
```
public static final int HKEY_DYN_DATA_INDEX
```
    The index in the listRoots() array for the HKEY_DYN_DATA registry key.
    
    See Also:
    Constant Field Values
  - OLD_COPY_TREE
```
public static final String OLD_COPY_TREE
```
    System property for using the old copy tree method instead of the new version.
    
    See Also:
    Constant Field Values
  - OLD_DELETE_TREE
```
public static final String OLD_DELETE_TREE
```
    System property for using the old delete tree method instead of the new version.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - RegistryKey
```
public RegistryKey(String subKey)
```
    Constructs a new RegistryKey rooted at HKEY_CURRENT_USER which goes all the way to subKey.
    
    The key that is formed from subKey does not have to exist in the registry.
    
    Parameters:
    subKey - The subkey under HKEY_CURRENT_USER.
    
    Throws:
    
    IllegalArgumentException - if subKey is null.
    See Also:
    RegistryKey(String, boolean), RegistryKey(String, boolean, boolean), RegistryKey(String, boolean, String), RegistryKey(String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(String subKey,
           boolean create)
```
    Constructs a new RegistryKey rooted at HKEY_CURRENT_USER which goes all the way to subKey.
    
    The key that is formed from subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist.
    
    Parameters:
    subKey - The subkey under HKEY_CURRENT_USER.
    create - If true, will create the specified key now.
    
    Throws:
    
    IllegalArgumentException - if subKey is null.
    
    RegistryException - if the key could not be created.
    See Also:
    RegistryKey(String), RegistryKey(String, boolean, boolean), RegistryKey(String, boolean, String), RegistryKey(String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(String subKey,
           boolean create,
           boolean nonVolatile)
```
    Constructs a new RegistryKey rooted at HKEY_CURRENT_USER which goes all the way to subKey.
    
    The key that is formed from subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist.
    
    Parameters:
    subKey - The subkey under HKEY_CURRENT_USER.
    create - If true, will create the specified key now.
    nonVolatile - true if the subKey should persist, false otherwise.
    
    Throws:
    
    IllegalArgumentException - if subKey is null.
    
    RegistryException - if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    RegistryKey(String), RegistryKey(String, boolean), RegistryKey(String, boolean, String), RegistryKey(String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(String subKey,
           boolean create,
           String clazz)
```
    Constructs a new RegistryKey rooted at HKEY_CURRENT_USER which goes all the way to subKey with a specific class name.
    
    The key that is formed from subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist. The class name will be applied to the key if it was created.
    
    Parameters:
    subKey - The subkey under HKEY_CURRENT_USER.
    create - If true, will create the specified key now.
    clazz - The user-defined class name for subKey.
    
    Throws:
    
    IllegalArgumentException - if subKey is null.
    
    RegistryException - if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    RegistryKey(String), RegistryKey(String, boolean), RegistryKey(String, boolean, boolean), RegistryKey(String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(String subKey,
           boolean create,
           String clazz,
           boolean nonVolatile)
```
    Constructs a new RegistryKey rooted at HKEY_CURRENT_USER which goes all the way to subKey with a specific class name.
    
    The key that is formed from subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist. The class name will be applied to the key if it was created.
    
    Parameters:
    subKey - The subkey under HKEY_CURRENT_USER.
    create - If true, will create the specified key now.
    clazz - The user-defined class name for subKey.
    nonVolatile - true if subKey should persist, false otherwise.
    
    Throws:
    
    IllegalArgumentException - if subKey is null.
    
    RegistryException - if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    RegistryKey(String), RegistryKey(String, boolean), RegistryKey(String, boolean, boolean), RegistryKey(String, boolean, String)
  - RegistryKey
```
public RegistryKey(RegistryKey root,
           String subKey)
```
    Constructs a new RegistryKey rooted at root which goes all the way to subKey.
    
    The key that is formed from root and subKey does not have to exist in the registry.
    
    Parameters:
    root - The root of the registry subtree.
    subKey - The subkey under root.
    
    Throws:
    
    IllegalArgumentException - if root or subKey is null.
    See Also:
    RegistryKey(RegistryKey, String, boolean), RegistryKey(RegistryKey, String, boolean, boolean), RegistryKey(RegistryKey, String, boolean, String), RegistryKey(RegistryKey, String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(RegistryKey root,
           String subKey,
           boolean create)
```
    Constructs a new RegistryKey rooted at root which goes all the way to subKey.
    
    The key that is formed from root and subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist.
    
    Parameters:
    root - The root of the registry subtree.
    subKey - The subkey under root.
    create - If true, will create the specified key now.
    
    Throws:
    
    IllegalArgumentException - if root or subKey is null.
    
    RegistryException - if the key could not be created.
    See Also:
    RegistryKey(RegistryKey, String), RegistryKey(RegistryKey, String, boolean, boolean), RegistryKey(RegistryKey, String, boolean, String), RegistryKey(RegistryKey, String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(RegistryKey root,
           String subKey,
           boolean create,
           boolean nonVolatile)
```
    Constructs a new RegistryKey rooted at root which goes all the way to subKey.
    
    The key that is formed from root and subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist.
    
    Parameters:
    root - The root of the registry subtree.
    subKey - The subkey under root.
    create - If true, will create the specified key now.
    nonVolatile - true if the subKey should persist, false otherwise.
    
    Throws:
    
    IllegalArgumentException - if root or subKey is null.
    
    RegistryException - if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    RegistryKey(RegistryKey, String), RegistryKey(RegistryKey, String, boolean), RegistryKey(RegistryKey, String, boolean, String), RegistryKey(RegistryKey, String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(RegistryKey root,
           String subKey,
           boolean create,
           String clazz)
```
    Constructs a new RegistryKey rooted at root which goes all the way to subKey with a specific class name.
    
    The key that is formed from root and subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist. The class name will be applied to the key if it was created.
    
    Parameters:
    root - The root of the registry subtree.
    subKey - The subkey under root.
    create - If true, will create the specified key now.
    clazz - The user-defined class name for subKey.
    
    Throws:
    
    IllegalArgumentException - if root or subKey is null.
    
    RegistryException - if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    RegistryKey(RegistryKey, String), RegistryKey(RegistryKey, String, boolean), RegistryKey(RegistryKey, String, boolean, boolean), RegistryKey(RegistryKey, String, boolean, String, boolean)
  - RegistryKey
```
public RegistryKey(RegistryKey root,
           String subKey,
           boolean create,
           String clazz,
           boolean nonVolatile)
```
    Constructs a new RegistryKey rooted at root which goes all the way to subKey with a specific class name.
    
    The key that is formed from root and subKey does not have to exist in the registry.
    
    An optional boolean value can be passed in to create the registry key if it doesn't exist. The class name will be applied to the key if it was created.
    
    Parameters:
    root - The root of the registry subtree.
    subKey - The subkey under root.
    create - If true will create the specified key now.
    clazz - The user-defined class name for subKey.
    nonVolatile - true if subKey should persist, false otherwise.
    
    Throws:
    
    IllegalArgumentException - if root or subKey is null.
    
    RegistryException - if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    RegistryKey(RegistryKey, String), RegistryKey(RegistryKey, String, boolean), RegistryKey(RegistryKey, String, boolean, boolean), RegistryKey(RegistryKey, String, boolean, String)
- Method Detail
  - autoExpandEnvironmentVariables
```
public static void autoExpandEnvironmentVariables(boolean auto)
```
    Specifies whether values of type REG_EXPAND_SZ should have their values expanded when returned from a call to getValue(String) or getValues().
    
    Note for v1.8:This method is now made thread safe with the use of an atomic variable.
    
    Parameters:
    auto - true if REG_EXPAND_SZ value data should be expanded, false otherwise.
    Since:
    
    1.7.3
  - connect
```
public static RegistryKey connect(String machine,
                  RegistryKey root)
```
    Connects to a remote registry on the computer named by machine. The remote computer must have the Remote Registry Service started, otherwise a connection won't be established to the remote computer's registry. If machine is null or has a length of 0, then this method connects to the local machine.
    
    Also, root must represent either HKEY_LOCAL_MACHINE, HKEY_USERS, or HKEY_PERFORMANCE_DATA.
    
    Parameters:
    machine - The name of the remote computer to connect to. Must be in the form: \\computername.
    root - The root key of the remote registry to connect to. Must be either HKEY_LOCAL_MACHINE, HKEY_USERS, or HKEY_PERFORMANCE_DATA.
    
    Returns:
    A RegistryKey object which represents the specified root key on a remote computer.
    
    Throws:
    
    IllegalArgumentException - if root is null.
    
    RegistryException - if root is not an allowed root key.
    Since:
    
    1.8
  - deleteKeys
```
public static int deleteKeys(RegistryKey... keys)
```
    Deletes a set of registry keys from the registry.
    Note: if an element of keys represents a symbolic link, then use the deleteLink() method on the element instead.
    
    Parameters:
    keys - The set of registry keys to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    deleteLinks(RegistryKey...)
  - deleteLinks
```
public static int deleteLinks(RegistryKey... keys)
```
    Deletes a set of symbolic link registry keys from the registry.
    
    Parameters:
    keys - The set of symbolic link registry keys to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    deleteKeys(RegistryKey...)
  - expandEnvironmentVariables
```
public static String expandEnvironmentVariables(String envStr)
```
    Allows data from values of REG_EXPAND_SZ to be expanded. This means that environment variables such as %SystemRoot% or %ProgramFiles% will become C:\Windows or C:\Program Files respectively.
    
    Parameters:
    envStr - The String containing the environment variable to expand.
    
    Returns:
    The expanded form of envStr.
  - formatErrorMessage
```
public static String formatErrorMessage(int code)
```
    Retrieves the description for an error code that was returned by a method in the RegistryKey class or one of the RegistryValue classes.
    
    Parameters:
    code - The error code returned from a method.
    
    Returns:
    A description of the error code.
  - getRegistryQuota
```
public static RegistryQuota getRegistryQuota()
```
    Retrieves the current size of the registry and the maximum size that the registry is allowed to attain on the system.
    
    Returns:
    A RegistryQuota object that contains the registry size values or null if the function is not supported on the current Windows system.
    Since:
    
    1.8
  - getRootKeyForIndex
```
public static RegistryKey getRootKeyForIndex(int index)
```
    Retrieves the root key based on the HKEY_*_INDEX values.
    
    Parameters:
    index - The index of the root key to retrieve, corresponds to the HKEY_*_INDEX values.
    
    Returns:
    The RegistryKey which is associated with the specified index.
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if index is negative or greater than the number of root keys.
    Since:
    
    1.8
  - isAutoExpandEnvironmentVariables
```
public static boolean isAutoExpandEnvironmentVariables()
```
    Determines whether values of type REG_EXPAND_SZ have their values automatically expanded when returned from a call to getValue(String) or getValues().
    
    Note for v1.8:This method is now made thread safe with the use of an atomic variable.
    
    Returns:
    true if REG_EXPAND_SZ value data should be expanded, false otherwise.
  - listRoots
```
public static RegistryKey[] listRoots()
```
    Retrieves an array of all the registry root keys.
    
    Returns:
    The registry root keys in an array.
  - parseKey
```
public static RegistryKey parseKey(String key)
```
    Tranforms the String path of a registry key into a RegistryKey object. The path must point to a key that currently exists in the registry.
    
    Parameters:
    key - The path to a registry key.
    
    Returns:
    A RegistryKey object represented by the path or null if the key does not exist.
    See Also:
    parseKey(String, boolean), parseKey(String, boolean, boolean)
  - parseKey
```
public static RegistryKey parseKey(String key,
                   boolean create)
```
    Tranforms the String path of a registry key into a RegistryKey object. The boolean parameter allows the returned key to be created if it doesn't exist.
    
    Parameters:
    key - The path to a registry key.
    create - If true creates the returned key.
    
    Returns:
    A RegistryKey object represented by the path or null if the key could not be created.
    Since:
    
    1.5.1
    
    See Also:
    parseKey(String), parseKey(String, boolean, boolean)
  - parseKey
```
public static RegistryKey parseKey(String key,
                   boolean create,
                   boolean nonVolatile)
```
    Tranforms the String path of a registry key into a RegistryKey object. The first optional boolean parameter allows the returned key to be created if it doesn't exist. The second boolean determines if the key should be permanent.
    
    Parameters:
    key - The path to a registry key.
    create - If true creates the returned key.
    nonVolatile - true if key should persist, false otherwise.
    
    Returns:
    A RegistryKey object represented by the path or null if the key could not be created.
  - canDelete
```
public boolean canDelete()
```
    Tests to see if this can be deleted. A registry key can only be deleted if it is not a root key and if it does not contain any subkeys.
    
    Returns:
    true if the key can be deleted, false otherwise.
    See Also:
    deleteKey(), deleteSubKey(String), deleteView64Key(String)
  - canDeleteLink
```
public boolean canDeleteLink()
```
    Tests to see if this can be deleted. A registry key can only be deleted if it is not a root key and if it does not contain any subkeys.
    
    Returns:
    true if the key can be deleted, false otherwise.
    Since:
    
    1.4
    
    See Also:
    deleteLink()
  - canDeleteTree
```
public boolean canDeleteTree()
```
    Tests to see if the subtree rooted at this can be deleted. A registry subtree can only be deleted if it is not a root key.
    
    Returns:
    true if the subtree can be deleted, false otherwise.
    See Also:
    deleteTree()
  - canLoadKey
```
public boolean canLoadKey()
```
    Tests to see if this can load a registry hive. A registry key can only load a hive if it is the HKEY_LOCAL_MACHINE or the HKEY_USERS key.
    
    Returns:
    true if the key can load a registry hive, false otherwise.
    See Also:
    loadKey(String, File)
  - canRename
```
public boolean canRename()
```
    Tests to see if this can be renamed. A registry key can only be renamed if it is not a root key.
    
    Returns:
    true if the key can be renamed, false otherwise.
    See Also:
    renameKey(String)
  - canUnLoadKey
```
public boolean canUnLoadKey()
```
    Tests to see if this can be unloaded from the registry. A registry key can only be unloaded if it is the direct descendant of the HKEY_LOCAL_MACHINE or the HKEY_USERS key.
    
    Returns:
    true if the key can be unloaded from the registry, false otherwise.
    See Also:
    unLoadKey()
  - canWrite
```
public boolean canWrite()
```
    Tests to see if values can be added to this.
    
    Returns:
    true if the key can have values, false otherwise.
    See Also:
    deleteValue(String), deleteValue(RegistryValue), newValue(String, ValueType), renameValue(RegistryValue, String)
  - clone
```
public Object clone()
```
    Creates a shallow copy of this.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    A copy of this key.
  - compareTo
```
public int compareTo(RegistryKey o)
```
    Implements the compareTo method in the interface Comparable. Allows a list of RegistryKeys to be sorted in ascending order. Null values always come before non-null values.
    
    Specified by:
    
    compareTo in interface Comparable<RegistryKey>
    
    Parameters:
    o - A RegistryKey to compare against this.
    
    Returns:
    An integer describing which one should be sorted first: if < 0, this should go first if > 0, o should go first
  - copy
```
@Deprecated
public void copy(RegistryKey to)
```
    Deprecated.
    
    Copies all of the subkeys and values from this to to.
    Note for v1.8: This method is now deprecated. The preferred method is copyTree(RegistryKey).
    
    Parameters:
    to - The destination RegistryKey for the copy operation.
  - copyTree
```
public int copyTree(RegistryKey dest)
```
    Copies all of the subkeys and values from this to dest. This method will fail if a registry link key is encountered.
    
    Note for v1.8: If the operating system is Windows Vista or higher, then this method uses the Windows function RegCopyTree. If not, then this method mimics the way that RegCopyTree works. If the older implementation is preferred, then set the system property OLD_COPY_TREE to "true".
    
    Parameters:
    dest - The destination RegistryKey for the copy operation.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    copyTree(RegistryKey, boolean), copySubTree(String, RegistryKey), copySubTree(String, RegistryKey, boolean)
  - copyTree
```
public int copyTree(RegistryKey dest,
           boolean copyLinks)
```
    Copies all of the subkeys and values from this to dest. This method will fail if a registry link key is encountered unless copyLinks is set to true.
    
    Note for v1.8: If the operating system is Windows Vista or higher, then this method uses the Windows function RegCopyTree. If not, then this method mimics the way that RegCopyTree works. If copyLinks is true, then this method will try to copy any link keys it finds without using RegCopyTree because that method can't copy links. If the older implementation is preferred, then set the system property OLD_COPY_TREE to "true".
    
    Parameters:
    dest - The destination RegistryKey for the copy operation.
    copyLinks - true if the physical link should be copied, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    copyTree(RegistryKey), copySubTree(String, RegistryKey), copySubTree(String, RegistryKey, boolean)
  - copySubTree
```
public int copySubTree(String subKey,
              RegistryKey dest)
```
    Copies all of the subkeys and values from subkey to dest. This method will fail if a registry link key is encountered.
    This method uses the Windows Vista implementation for copying a subtree.
    
    Parameters:
    subKey - The subkey tree under this to copy.
    dest - The destination RegistryKey for the copy operation.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    copyTree(RegistryKey), copyTree(RegistryKey, boolean), copySubTree(String, RegistryKey, boolean)
  - copySubTree
```
public int copySubTree(String subKey,
              RegistryKey dest,
              boolean copyLinks)
```
    Copies all of the subkeys and values from subkey to dest. This method will fail if a registry link key is encountered unless copyLinks is set to true.
    This method uses the Windows Vista implementation for copying a subtree. If copyLinks is true, then this method will try to copy any link keys it finds without using RegCopyTree because that method can't copy links.
    
    Parameters:
    subKey - The subkey tree under this to copy.
    dest - The destination RegistryKey for the copy operation.
    copyLinks - true if the physical link should be copied, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    copyTree(RegistryKey), copyTree(RegistryKey, boolean), copySubTree(String, RegistryKey)
  - copyValue
```
public int copyValue(RegistryKey dest,
            RegistryValue value)
```
    Copies the registry value represented by value to the registry key dest.
    
    Parameters:
    value - The registry value to copy.
    dest - The registry key that value should be copied to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), copyValues(RegistryKey, String...), copyValues(RegistryKey, RegistryValue...)
  - copyValues
```
public int copyValues(RegistryKey dest,
             String... va)
```
    Copies the set of registry values named by va to the registry key dest.
    
    Parameters:
    va - The set of names of the registry values to copy.
    dest - The registry key that the names in va should be copied to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), copyValue(RegistryKey, RegistryValue), copyValues(RegistryKey, RegistryValue...)
  - copyValues
```
public int copyValues(RegistryKey dest,
             RegistryValue... va)
```
    Copies the set of registry values represented by va to the registry key dest.
    
    Parameters:
    va - A set of registry values to copy.
    dest - The registry key that the values in va should be copied to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), copyValue(RegistryKey, RegistryValue), copyValues(RegistryKey, String...)
  - copySubKeyValue
```
public int copySubKeyValue(String subKey,
                  RegistryKey dest,
                  RegistryValue value)
```
    Copies the registry value represented by value within subKey to the registry key dest.
    
    Parameters:
    subKey - The subkey from which the values will be copied from.
    value - The registry value to copy.
    dest - The registry key that value should be copied to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), copySubKeyValues(String, RegistryKey, String...), copySubKeyValues(String, RegistryKey, RegistryValue...)
  - copySubKeyValues
```
public int copySubKeyValues(String subKey,
                   RegistryKey dest,
                   String... va)
```
    Copies the set of registry values named by va within subKey to the registry key dest.
    
    Parameters:
    subKey - The subkey from which the values will be copied from.
    va - The set of names of the registry values to copy.
    dest - The registry key that the names in va should be copied to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), copySubKeyValue(String, RegistryKey, RegistryValue), copySubKeyValues(String, RegistryKey, RegistryValue...)
  - copySubKeyValues
```
public int copySubKeyValues(String subKey,
                   RegistryKey dest,
                   RegistryValue... va)
```
    Copies the set of registry values represented by va within subKey to the registry key dest.
    
    Parameters:
    subKey - The subkey from which the values will be copied from.
    va - A set of registry values to copy.
    dest - The registry key that the values in va should be copied to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), copySubKeyValue(String, RegistryKey, RegistryValue), copySubKeyValues(String, RegistryKey, String...)
  - create
```
public int create()
```
    Creates the key represented by this in the registry.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    create(boolean), create(String), create(String, boolean)
  - create
```
public int create(boolean nonVolatile)
```
    Creates the key represented by this in the registry.
    
    Parameters:
    nonVolatile - true if this should persist, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    create(), create(String), create(String, boolean)
  - create
```
public int create(String clazz)
```
    Creates the key represented by this in the registry with the specified class name.
    
    Parameters:
    clazz - The class name for this.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    create(), create(boolean), create(String, boolean)
  - create
```
public int create(String clazz,
         boolean nonVolatile)
```
    Creates the key represented by this in the registry with the specified class name.
    
    Parameters:
    clazz - The class name for this.
    nonVolatile - true if this should persist, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    create(), create(boolean), create(String)
  - created
```
public boolean created()
```
    Retrieves whether or not this was created or if it already existed in the registry.
    
    Returns:
    true if the key was created, false otherwise.
  - createLink
```
public int createLink(RegistryKey target)
```
    Creates the key represented by this in the registry as a link to another key.
    
    Parameters:
    target - The RegistryKey to link to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    createLink(RegistryKey, boolean), createLink(RegistryKey, String), createLink(RegistryKey, String, boolean)
  - createLink
```
public int createLink(RegistryKey target,
             boolean nonVolatile)
```
    Creates the key represented by this in the registry as a link to another key.
    
    Parameters:
    target - The RegistryKey to link to.
    nonVolatile - true if this should persist, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    createLink(RegistryKey), createLink(RegistryKey, String), createLink(RegistryKey, String, boolean)
  - createLink
```
public int createLink(RegistryKey target,
             String clazz)
```
    Creates the key represented by this in the registry with the specified class name as a link to another key.
    
    Parameters:
    target - The RegistryKey to link to.
    clazz - The class name for this.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    createLink(RegistryKey), createLink(RegistryKey, boolean), createLink(RegistryKey, String, boolean)
  - createLink
```
public int createLink(RegistryKey target,
             String clazz,
             boolean nonVolatile)
```
    Creates the key represented by this in the registry with the specified class name as a link to another key.
    
    Parameters:
    target - The RegistryKey to link to.
    clazz - The class name for this.
    nonVolatile - true if this should persist, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    createLink(RegistryKey), createLink(RegistryKey, boolean), createLink(RegistryKey, String)
  - createSubKey
```
public RegistryKey createSubKey(String subKey)
```
    Creates a new subkey under this. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    See Also:
    createSubKey(String, boolean), createSubKey(String, String), createSubKey(String, String, boolean)
  - createSubKey
```
public RegistryKey createSubKey(String subKey,
                       boolean nonVolatile)
```
    Creates a new subkey under this. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    nonVolatile - true if subKey should persist, false otherwise.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKey(String), createSubKey(String, String), createSubKey(String, String, boolean)
  - createSubKey
```
public RegistryKey createSubKey(String subKey,
                       String clazz)
```
    Creates a new subkey under this with the specified class name. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    clazz - The class name for this.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKey(String), createSubKey(String, boolean), createSubKey(String, String, boolean)
  - createSubKey
```
public RegistryKey createSubKey(String subKey,
                       String clazz,
                       boolean nonVolatile)
```
    Creates a new subkey under this with the specified class name. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    clazz - The class name for this.
    nonVolatile - true if subKey should persist, false otherwise.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKey(String), createSubKey(String, boolean), createSubKey(String, String)
  - createSubKeyLink
```
public RegistryKey createSubKeyLink(String subKey,
                           RegistryKey target)
```
    Creates a new subkey under this which will link to another key. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    target - The RegistryKey to link to.
    
    Returns:
    The new RegistryKey representing subkey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKeyLink(String, RegistryKey, boolean), createSubKeyLink(String, RegistryKey, String), createSubKeyLink(String, RegistryKey, String, boolean)
  - createSubKeyLink
```
public RegistryKey createSubKeyLink(String subKey,
                           RegistryKey target,
                           boolean nonVolatile)
```
    Creates a new subkey under this which will link to another key. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    target - The RegistryKey to link to.
    nonVolatile - true if subKey should persist, false otherwise.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKeyLink(String, RegistryKey), createSubKeyLink(String, RegistryKey, String), createSubKeyLink(String, RegistryKey, String, boolean)
  - createSubKeyLink
```
public RegistryKey createSubKeyLink(String subKey,
                           RegistryKey target,
                           String clazz)
```
    Creates a new subkey under this with the specified class name as a link to another key. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    target - The RegistryKey to link to.
    clazz - The class name for this.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKeyLink(String, RegistryKey), createSubKeyLink(String, RegistryKey, boolean), createSubKeyLink(String, RegistryKey, String, boolean)
  - createSubKeyLink
```
public RegistryKey createSubKeyLink(String subKey,
                           RegistryKey target,
                           String clazz,
                           boolean nonVolatile)
```
    Creates a new subkey under this with the specified class name as a link to another key. If the key could not be created, then null is returned.
    
    Parameters:
    subKey - The subkey under this to create.
    target - The RegistryKey to link to.
    clazz - The class name for this.
    nonVolatile - true if subKey should persist, false otherwise.
    
    Returns:
    The new RegistryKey representing subKey or null if the key could not be created.
    Since:
    
    1.4
    
    See Also:
    createSubKeyLink(String, RegistryKey), createSubKeyLink(String, RegistryKey, boolean), createSubKeyLink(String, RegistryKey, String)
  - deleteKey
```
public int deleteKey()
```
    Deletes this from the registry.
    Note: if this represents a symbolic link, then use the deleteLink() method instead.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canDelete(), deleteSubKey(String), deleteSubKeys(String...), deleteView64Key(String), deleteView64Keys(String...)
  - deleteLink
```
public int deleteLink()
```
    Deletes this symbolic link from the registry.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.4
    
    See Also:
    canDeleteLink()
  - deleteSubKey
```
public int deleteSubKey(String subKey)
```
    Deletes subKey from this.
    Note: if subKey represents a symbolic link, then use the deleteLink() method on the subkey instead.
    
    Parameters:
    subKey - The subkey under this to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canDelete(), deleteKey(), deleteSubKeys(String...), deleteView64Key(String), deleteView64Keys(String...)
  - deleteSubKeys
```
public int deleteSubKeys(String... subKeys)
```
    Deletes the subKeys from this.
    Note: if an element of subKeys represents a symbolic link, then use the deleteLink() method on the subkey instead.
    
    Parameters:
    subKeys - The subkeys under this to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canDelete(), deleteKey(), deleteSubKey(String), deleteView64Key(String), deleteView64Keys(String...)
  - deleteView64Key
```
public int deleteView64Key(String subKey)
```
    Deletes subKey from a 64-bit specific view of the registry from this if isViewing64BitRegistry() is true. Otherwise subKey is deleted from the 32-bit specific view of the registry.
    Note: if subKey represents a symbolic link, then use the deleteLink() method on the subkey instead.
    
    Parameters:
    subKey - The subkey under this to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canDelete(), deleteKey(), deleteSubKey(String), deleteSubKeys(String...), deleteView64Keys(String...), isViewing64BitRegistry(), view64BitRegistry(boolean)
  - deleteView64Keys
```
public int deleteView64Keys(String... subKeys)
```
    Deletes the subKeys from a 64-bit specific view of the registry from this if isViewing64BitRegistry() is true. Otherwise the subKeys are deleted from the 32-bit specific view of the registry.
    Note: if an element of subKeys represents a symbolic link, then use the deleteLink() method on the subkey instead.
    
    Parameters:
    subKeys - The subkeys under this to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canDelete(), deleteKey(), deleteSubKey(String), deleteSubKeys(String...), deleteView64Key(String), isViewing64BitRegistry(), view64BitRegistry(boolean)
  - deleteTree
```
public int deleteTree()
```
    Deletes the entire subtree rooted at this from the registry.
    Note: if this represents a symbolic link, then use the deleteLink() method instead.
    Note for v1.8: The implementation for this method has changed. If the operating system is Windows Vista or higher, then this method uses the Windows function RegDeleteTree. If not, then this method mimics the way that RegDeleteTree works. This means that only the subkeys and values under this key will be deleted, not this. If the older implementation is preferred, then set the system property OLD_DELETE_TREE to "true".
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canDeleteTree(), deleteTree(boolean), deleteSubTree(String), deleteSubTree(String, boolean)
  - deleteTree
```
public int deleteTree(boolean delLinks)
```
    Deletes the entire subtree rooted at this from the registry.
    Note: if this represents a symbolic link, then use the deleteLink() method instead.
    
    If the operating system is Windows Vista or higher, then this method uses the Windows function RegDeleteTree. If not, then this method mimics the way that RegDeleteTree works. This means that only the subkeys and values under this key will be deleted, not this. If delLinks is true, then this method will try to delete any link keys it finds without using RegDeleteTree because that method can't delete links. If the older implementation is preferred, then set the system property OLD_DELETE_TREE to "true".
    
    Parameters:
    delLinks - true if link keys should be deleted, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canDeleteTree(), deleteTree(), deleteSubTree(String), deleteSubTree(String, boolean)
  - deleteSubTree
```
public int deleteSubTree(String subKey)
```
    Deletes the entire subtree rooted at subKey from the registry.
    This method uses the Windows Vista implementation for deleting a subtree.
    Note: if subKey represents a symbolic link, then use the deleteLink() method on the subkey instead.
    
    Parameters:
    subKey - The subkey tree under this to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canDeleteTree(), deleteTree(), deleteTree(boolean), deleteSubTree(String, boolean)
  - deleteSubTree
```
public int deleteSubTree(String subKey,
                boolean delLinks)
```
    Deletes the entire subtree rooted at subKey from the registry.
    This method uses the Windows Vista implementation for deleting a subtree. If delLinks is true, then this method will try to delete any link keys it finds without using RegDeleteTree because that method can't delete links.
    Note: if subKey represents a symbolic link, then use the deleteLink() method on the subkey instead.
    
    Parameters:
    subKey - The subkey tree under this to delete.
    delLinks - true if link keys should be deleted, false otherwise.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canDeleteTree(), deleteTree(), deleteTree(boolean), deleteSubTree(String)
  - deleteValue
```
public int deleteValue(String value)
```
    Deletes a named value from this.
    
    Parameters:
    value - The name of the value to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canWrite(), deleteValue(RegistryValue), deleteValues(String...), deleteValues(RegistryValue...), deleteSubKeyValue(String, String), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, String...), deleteSubKeyValues(String, RegistryValue...)
  - deleteValue
```
public int deleteValue(RegistryValue value)
```
    Deletes a named value represented by value from this.
    
    Parameters:
    value - The RegistryValue to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canWrite(), deleteValue(String), deleteValues(String...), deleteValues(RegistryValue...), deleteSubKeyValue(String, String), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, String...), deleteSubKeyValues(String, RegistryValue...)
  - deleteValues
```
public int deleteValues(String... va)
```
    Deletes a set of named values within va from this.
    
    Parameters:
    va - The set of names of the values to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), deleteValue(String), deleteValue(RegistryValue), deleteValues(RegistryValue...), deleteSubKeyValue(String, String), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, String...), deleteSubKeyValues(String, RegistryValue...)
  - deleteValues
```
public int deleteValues(RegistryValue... va)
```
    Deletes a set of named values represented by RegistryValues within va from this.
    
    Parameters:
    va - The set of RegistryValues to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), deleteValue(String), deleteValue(RegistryValue), deleteValues(String...), deleteSubKeyValue(String, String), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, String...), deleteSubKeyValues(String, RegistryValue...)
  - deleteSubKeyValue
```
public int deleteSubKeyValue(String subKey,
                    String value)
```
    Deletes a named value from subKey. If subKey is null or has a length of 0, then this behaves exactly as deleteValue(String).
    
    Parameters:
    subKey - The subKey from which to delete the value.
    value - The name of the value to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), deleteValue(String), deleteValue(RegistryValue), deleteValues(String...), deleteValues(RegistryValue...), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, String...), deleteSubKeyValues(String, RegistryValue...)
  - deleteSubKeyValue
```
public int deleteSubKeyValue(String subKey,
                    RegistryValue value)
```
    Deletes a named value represented by value from subKey. If subKey is null or has a length of 0, then this behaves exactly as deleteValue(RegistryValue).
    
    Parameters:
    subKey - The subKey from which to delete the value.
    value - The RegistryValue to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), deleteValue(String), deleteValue(RegistryValue), deleteValues(String...), deleteValues(RegistryValue...), deleteSubKeyValue(String, String), deleteSubKeyValues(String, String...), deleteSubKeyValues(String, RegistryValue...)
  - deleteSubKeyValues
```
public int deleteSubKeyValues(String subKey,
                     String... va)
```
    Deletes a set of named values within va from subKey. If subKey is null or has a length of 0, then this behaves exactly as deleteValues(String...).
    
    Parameters:
    subKey - The subKey from which to delete the values.
    va - The set of names of the values to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), deleteValue(String), deleteValue(RegistryValue), deleteValues(String...), deleteValues(RegistryValue...), deleteSubKeyValue(String, String), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, RegistryValue...)
  - deleteSubKeyValues
```
public int deleteSubKeyValues(String subKey,
                     RegistryValue... va)
```
    Deletes a set of named values represented by va from subKey. If subKey is null or has a length of 0, then this behaves exactly as deleteValues(RegistryValue...).
    
    Parameters:
    subKey - The subKey from which to delete the values.
    va - The set of RegistryValues to delete.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.8
    
    See Also:
    canWrite(), deleteValue(String), deleteValue(RegistryValue), deleteValues(String...), deleteValues(RegistryValue...), deleteSubKeyValue(String, String), deleteSubKeyValue(String, RegistryValue), deleteSubKeyValues(String, String...)
  - disableReflection
```
public int disableReflection()
```
    Disables registry reflection for this key.
    Note: This method only works on 64-bit versions of Windows XP and higher.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.6
    
    See Also:
    disableReflectionTree()
  - disableReflectionTree
```
public int disableReflectionTree()
```
    Disables registry reflection for this key and its entire subtree.
    Note: This method only works on 64-bit versions of Windows XP and higher.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.6
    
    See Also:
    disableReflection()
  - enableReflection
```
public int enableReflection()
```
    Enables registry reflection for this key.
    Note: This method only works on 64-bit versions of Windows XP and higher.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.6
    
    See Also:
    enableReflectionTree()
  - enableReflectionTree
```
public int enableReflectionTree()
```
    Enables registry reflection for this key and its entire subtree.
    Note: This method only works on 64-bit versions of Windows XP and higher.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.6
    
    See Also:
    enableReflection()
  - equals
```
public boolean equals(Object o)
```
    Tests for equality with another Object. Two Objects are equal if they are both of type RegistryKey, and both of their names are the same.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    o - An Object to test equality with.
    
    Returns:
    true if the two are equal, false otherwise.
  - exists
```
public boolean exists()
```
    Tests to see if this exists in the registry.
    
    Returns:
    true if this exists, false otherwise.
  - flushKey
```
public int flushKey()
```
    Writes all attributes of this into the registry.
    
    Calling flushKey is an expensive operation that will signficantly affect performance because it blocks modifications to this until the flush operation completes.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
  - getClassName
```
public String getClassName()
```
    Retrieves the class name for this if it is set.
    
    Returns:
    The class name of this if set or null otherwise.
  - getCurrentUserSid
```
public static String getCurrentUserSid()
```
    Retrieves the current user's SID in String format.
    
    Returns:
    A String representation of the current user's SID.
    Since:
    
    1.4
  - getIndex
```
public int getIndex()
```
    Retrieves the index of this under the parent. The index is zero based.
    
    Returns:
    The index of this or Integer.MIN_VALUE if this is a root key or if this no longer exists.
  - getKeyInfo
```
public int[] getKeyInfo()
```
    Retrieves information about this. The information includes:
    - The number of subkeys in this
    - The length of the name of the longest subkey
    - The length of the class name for this
    - The number of values in this
    - The length of the name of the longest value
    - The number of bytes in the largest data component of the values
    Returns:
    An array of integers containing various information about this or null if an error occurred.
  - getLastError
```
public int getLastError()
```
    Retrieves the error code from the last open operation on this.
    
    Returns:
    The last error from an open operation.
  - getLevel
```
public int getLevel()
```
    Retrieves the level in the registry that this resides in.
    
    Returns:
    The level in the registry for this.
  - getLinkLocation
```
public RegistryKey getLinkLocation()
```
    Retrieves the RegistryKey that this is linked to or null if this is not a link.
    
    Returns:
    The target of this if it is a link.
    Since:
    
    1.4
  - getName
```
public String getName()
```
    Used to retrieve the name of this key.
    
    Returns:
    The name of this.
  - getNumberOfSubKeys
```
public int getNumberOfSubKeys()
```
    Retrieves the number of subkeys that are under this.
    
    Returns:
    The number of subkeys under this.
  - getNumberOfValues
```
public int getNumberOfValues()
```
    Retrieves the number of values that are in this.
    
    Returns:
    The number of values in this.
  - getParent
```
public RegistryKey getParent()
```
    Retrieves the parent RegistryKey of this. If this refers to a root key, then null is returned.
    
    Returns:
    The parent of this or null if this is a root.
  - getPath
```
public String getPath()
```
    Retrieves the path in the registry which points to this.
    
    Returns:
    The path in the registry to this.
  - getRootIndex
```
public int getRootIndex()
```
    Retrieves the index of the root key of this in the listRoots() array.
    
    Returns:
    The index of the parent root key in the listRoots() array of this.
  - getRootKey
```
public RegistryKey getRootKey()
```
    Retrieves the root key for this. A root key is similar to HKEY_CURRENT_USER or HKEY_LOCAL_MACHINE.
    
    Returns:
    The parent root key of this.
  - getSubKey
```
public RegistryKey getSubKey(String name)
```
    Retrieves a RegistryKey which represents the subkey with a name of name under this. If the key doesn't exist, then null is returned.
    
    Parameters:
    name - The name of the subkey to get.
    
    Returns:
    A RegistryKey which is a subkey of this with name name or null if the key doesn't exist.
    Since:
    
    1.5.4
    
    See Also:
    getSubKeyNames(), getSubKeys(), subKeysIterator(), subKeyNamesIterator()
  - getSubKeyNames
```
public String[] getSubKeyNames()
```
    Retrieves a sorted array of Strings which are the names of the subkeys under this. The method returns null when an error occurs.
    
    Returns:
    A sorted array of the names of the subkeys of this or null if an error occured.
    See Also:
    getSubKey(String), getSubKeys(), getSubKeys(String...), subKeysIterator(), subKeyNamesIterator()
  - getSubKeys
```
public List<RegistryKey> getSubKeys()
```
    Retrieves a list of RegistryKeys which represent the subkeys that are under this. The list is unsorted. The method returns null when an error occurs.
    
    Returns:
    An unsorted list of RegistryKeys that are the subkeys of this or null if an error occured.
    See Also:
    getSubKey(String), getSubKeyNames(), getSubKeys(String...), subKeysIterator(), subKeyNamesIterator()
  - getSubKeys
```
public List<RegistryKey> getSubKeys(String... subKeys)
```
    Retrieves a list of RegistryKeys which are specified by the names in subKeys that are under this. The method returns null when an error occurs.
    
    Parameters:
    subKeys - The names of the subkeys to retrieve.
    
    Returns:
    A list of RegistryKeys that are the subkeys of this named by subKeys or null if an error occured.
    Since:
    
    1.8
    
    See Also:
    getSubKey(String), getSubKeyNames(), getSubKeys(), subKeysIterator(), subKeyNamesIterator()
  - getSystemTime
```
public SystemTime getSystemTime()
```
    Retrieves the last write time of this as a SystemTime object.
    
    Returns:
    The last write time of this as a SystemTime object.
    See Also:
    SystemTime
  - getValue
```
public RegistryValue getValue(String name)
```
    Retrieves a RegistryValue which represents the value with a name of name under this.
    
    If the value does not exist, then null is returned.
    
    Parameters:
    name - The name of the value to obtain.
    
    Returns:
    A RegistryValue which represents the value named by name or null if the value doesn't exist.
    See Also:
    getValueNames(), getValues(), getValues(String...), valuesIterator(), valueNamesIterator()
  - getValueNames
```
public String[] getValueNames()
```
    Retrieves a sorted array of Strings which are the names of the values under this. The method returns null when an error occurs.
    
    Returns:
    A sorted array of the names of the values of this key or null if an error occured.
    See Also:
    getValue(String), getValues(), getValues(String...), valuesIterator(), valueNamesIterator()
  - getValues
```
public List<RegistryValue> getValues()
```
    Retrieves a list of RegistryValues which represent the values that are under this. The list is unsorted. The method returns null when an error occurs.
    
    Returns:
    An unsorted list of RegistryValues that are the values of this key or null if an error occured.
    See Also:
    getValue(String), getValueNames(), getValues(String...), valuesIterator(), valueNamesIterator()
  - getValues
```
public List<RegistryValue> getValues(String... va)
```
    Retrieves a list of RegistryValues which represent the values that are named by va. The method returns null if an error occurs.
    
    Parameters:
    va - The names of the values to retrieve.
    
    Returns:
    A list of RegistryValues that are named by va under this or null if an error occurs.
    Since:
    
    1.8
    
    See Also:
    getValue(String), getValueNames(), getValues(), valuesIterator(), valueNamesIterator()
  - getValueType
```
public static ValueType getValueType(int type)
```
    Convenience method to retrieve the ValueType object based on the integer type that is passed in. If type is not a legal registry value type, then null is returned.
    
    Parameters:
    type - An integer representing a value type.
    
    Returns:
    A ValueType object based on the integer type or null if type is not a legal registry value type.
  - hasDefaultValue
```
public boolean hasDefaultValue()
```
    Convenience method to test to see if this contains the default or unnamed value.
    
    Returns:
    true if the default value exists, false otherwise.
  - hashCode
```
public int hashCode()
```
    Calculates the hash code value for this.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    The hash code for this.
  - hasSubKeys
```
public boolean hasSubKeys()
```
    Convenience method to test to see if this contains any subkeys.
    
    Returns:
    true if subkeys exist, false otherwise.
  - hasValues
```
public boolean hasValues()
```
    Convenience method to test to see if this contains any values.
    
    Returns:
    true if values exist, false otherwise.
  - isLinkKey
```
public boolean isLinkKey()
```
    Checks to see whether this key is a symbolic link to another key.
    
    Returns:
    true if the key is a link, or false otherwise.
    Since:
    
    1.4
  - isRemoteRegistryKey
```
public boolean isRemoteRegistryKey()
```
    Checks to see whether this key is a remote registry key.
    
    Returns:
    true if the key is a remote registry key, or false otherwise.
    Since:
    
    1.8
  - isViewing64BitRegistry
```
public boolean isViewing64BitRegistry()
```
    Determines if the key is viewing the 64-bit registry or the 32-bit registry.
    
    Returns:
    true if the 64-bit registry is being viewed, false otherwise.
    Since:
    
    1.6
  - keyExists
```
public boolean keyExists(String subKey)
```
    Tests to see if the specified subkey exists under this.
    
    Parameters:
    subKey - The subkey whose existence will be tested.
    
    Returns:
    true if subKey exists, false otherwise.
  - keyIsLink
```
public boolean keyIsLink(String subKey)
```
    Tests to see if the specified subkey under this is a link.
    
    Parameters:
    subKey - The subkey whose existence will be tested.
    
    Returns:
    true if subKey exists, false otherwise.
    Since:
    
    1.5.1
  - lastModified
```
public long lastModified()
```
    Returns the time that the key denoted by this was last modified.
    
    Returns:
    A long value representing the time the key was last modified, measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970), or 0L if the key does not exist.
    Since:
    
    1.5.4
  - loadKey
```
public int loadKey(String subKey,
          File regFile)
```
    Creates a subkey under HKEY_USERS or HKEY_LOCAL_MACHINE and loads the data from the specified registry hive into that subkey.
    
    Parameters:
    subKey - The subkey to create.
    regFile - The registry hive that contains the information to load.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canLoadKey()
  - newValue
```
public RegistryValue newValue(String name,
                     ValueType type)
```
    Creates a new value under this with the specified name and type. The newly created value is then returned. If the value name already exists in the registry, then null is returned.
    
    Parameters:
    name - The name of the value to create.
    type - The type of the value.
    
    Returns:
    The newly create value or null if it already exists or an error occurred.
    See Also:
    canWrite()
  - newValue
```
public RegistryValue newValue(String name,
                     int type)
```
    Creates a new value under this with the specified name and type. The newly created value is then returned. If the value name already exists in the registry, then null is returned.
    
    Parameters:
    name - The name of the value to create.
    type - The type of the value.
    
    Returns:
    The newly create value or null if it already exists or an error occurred.
    See Also:
    canWrite()
  - queryReflection
```
public boolean queryReflection()
```
    Determines whether registry reflection for this key is turned off.
    Note: This method only works on 64-bit versions of Windows XP and higher.
    
    Returns:
    true if reflection is disabled, false otherwise
    Since:
    
    1.6
  - renameKey
```
public boolean renameKey(String newKeyName)
```
    Renames this to newKeyName.
    
    Returns:
    true if the rename completed successfully, false otherwise.
    See Also:
    canRename()
  - renameValue
```
public boolean renameValue(String old,
                  String newValueName)
```
    Renames the value specified by the name old to newValueName.
    
    Parameters:
    old - The name of the current value to rename.
    newValueName - The new name of the value.
    
    Returns:
    true if the rename completed successfully, false otherwise.
    Since:
    
    1.8
    
    See Also:
    canWrite(), renameValue(RegistryValue, String)
  - renameValue
```
public boolean renameValue(RegistryValue old,
                  String newValueName)
```
    Renames the value specified by old to newValueName.
    
    Parameters:
    old - The current value to rename.
    newValueName - The new name of the value.
    
    Returns:
    true if the rename completed successfully, false otherwise.
    See Also:
    canWrite(), renameValue(String, String)
  - replaceKey
```
public int replaceKey(File newRegFile,
             File oldRegFile)
```
    Replaces the file backing this key and all the subkeys with another file, so that when the system is next started, the key and subkeys will have the values stored in the new file.
    
    Parameters:
    newRegFile - The file containing the new information for the key.
    oldRegFile - The file that will be receive a backup of the information being replaced.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
  - replaceSubKey
```
public int replaceSubKey(String subKey,
                File newRegFile,
                File oldRegFile)
```
    Replaces the file backing the subkey of this key and all its subkeys with another file, so that when the system is next started, the key and subkeys will have the values stored in the new file.
    
    Parameters:
    subKey - The subkey under this key.
    newRegFile - The file containing the new information for the key.
    oldRegFile - The file that will be receive a backup of the information being replaced.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
  - restoreKey
```
public int restoreKey(File regFile)
```
    Reads the registry information in a specified file and copies it over this key. This registry information may be in the form of a key and multiple levels of subkeys.
    
    Parameters:
    regFile - The file containing the registry information to restore.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
  - restoreKey
```
public int restoreKey(File regFile,
             boolean force)
```
    Reads the registry information in a specified file and copies it over this key. This registry information may be in the form of a key and multiple levels of subkeys.
    
    Parameters:
    regFile - The file containing the registry information to restore.
    force - Force the restore operation to execute even if this key or subkeys of this have open handles.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    Since:
    
    1.7.5
  - saveKey
```
public int saveKey(File regFile)
            throws IOException
```
    Saves this and all subkeys and values to a new file, in the standard format.
    
    Parameters:
    regFile - The file to save to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    
    Throws:
    
    IOException - If regFile already exists and a temporary file could not be created.
    See Also:
    saveKey(boolean, boolean, File)
  - saveKey
```
public int saveKey(boolean latest,
          boolean noCompress,
          File regFile)
            throws IOException
```
    Saves this and all subkeys and values to a new file, in the specified format. The standard format is the only format supported by Windows 2000. The latest format works for Windows XP and higher. If noCompress is true, then this should be a root hive under HKEY_LOCAL_MACHINE or HKEY_USERS. For example, HKEY_LOCAL_MACHINE\SOFTWARE is the root of a hive.
    
    This method will only work on Windows XP systems or higher. If run on Windows 2000, then this method will perform exactly like saveKey(File).
    
    Parameters:
    latest - true if the hive should be saved using the lastest format, false otherwise.
    noCompress - true if the hive should not be saved with compression, false otherwise.
    regFile - The file to save to.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    
    Throws:
    
    IOException - If regFile already exists and a temporary file could not be created.
    Since:
    
    1.8
    
    See Also:
    saveKey(File)
  - searchIntegerValue
```
public int searchIntegerValue(int startIndex,
                     long value)
```
    Allows this key's integer values (REG_DWORD and REG_QWORD, etc.) to be searched for a particular value. The index, if not -1, corresponds to the index of the value in a sorted list.
    
    Parameters:
    startIndex - The index for the value to start with.
    value - The integer key to search for.
    
    Returns:
    The index of the value that matches the key, or -1 if the key was not found.
  - searchStringValue
```
public int searchStringValue(int startIndex,
                    String key)
```
    Allows this key's string values (REG_SZ, REG_EXPAND_SZ and REG_MULTI_SZ) to be searched for a particular value. This method is just a wrapper that searches the values starting at the specified value index. It tests the value names as well as the data for any part that matches the passed in key to search for. The index, if not -1, corresponds to the index of the value in a sorted list.
    
    Parameters:
    startIndex - The index for the value to start with.
    key - The string key to search for.
    
    Returns:
    The index of the value that matches the key, either in the name or data, or -1 if the key was not found.
  - searchStringValue
```
public int searchStringValue(int startIndex,
                    boolean valueName,
                    boolean data,
                    boolean matchStr,
                    String key)
```
    Allows this key's string values (REG_SZ, REG_EXPAND_SZ and REG_MULTI_SZ) to be searched for a particular value. The parameters for this method allow for the value name as well as the value's data to be searched. Also if matchStr is true, then the entire value name or data must match the passed in search key. The index, if not -1, corresponds to the index of the value in a sorted list.
    
    Parameters:
    startIndex - The index for the value to start with.
    valueName - true if the names of the values should be searched.
    data - true if the data of the values should be searched.
    matchStr - true if match should be constrained to the entire name or data, false if only a portion of the name or data contains the search key.
    key - The string key to search for.
    
    Returns:
    The index of the value that matches the key, either in the name or data, or -1 if the key was not found.
  - searchBinaryValue
```
public int searchBinaryValue(int startIndex,
                    byte[] value)
```
    Allows this key's binary values (REG_NONE, REG_BINARY, etc.) to be searched for a particular value. The index, if not -1, corresponds to the index of the value in a sorted list.
    
    Parameters:
    startIndex - The index for the value to start with.
    value - The binary key to search for.
    
    Returns:
    The index of the value that matches the key, or -1 if the key was not found.
    Since:
    
    1.6.1
  - setLinkTo
```
public boolean setLinkTo(RegistryKey target)
```
    If this represents a symbolic link, then the target for this will be changed to the key represented by target.
    
    Parameters:
    target - The RegistryKey to link to.
    
    Returns:
    true if the link was changed, false otherwise.
    Since:
    
    1.4
  - subKeyNamesIterator
```
public Iterator<String> subKeyNamesIterator()
```
    Retrieves an Iterator of Strings which represent the names of the subkeys that are under this. If the subkeys of this are changed from outside the iterator while an iteration is in progress, then a ConcurrentModificationException is thrown. If an error occurs, then null is returned.
    
    Returns:
    An Iterator of Strings that are the names of the subkeys of this or null if an error occurs.
    Since:
    
    1.8
    
    See Also:
    getSubKey(String), getSubKeyNames(), getSubKeys(), getSubKeys(String...), subKeysIterator()
  - subKeysIterator
```
public Iterator<RegistryKey> subKeysIterator()
```
    Retrieves an Iterator of RegistryKeys which represent the subkeys that are under this. If the subkeys of this are changed from outside the iterator while an iteration is in progress, then a ConcurrentModificationException is thrown. If an error occurs, then null is returned.
    
    Returns:
    An Iterator of RegistryKeys that are the subkeys of this or null if an error occurs.
    Since:
    
    1.8
    
    See Also:
    getSubKey(String), getSubKeyNames(), getSubKeys(), getSubKeys(String...), subKeyNamesIterator()
  - toNativePath
```
public String toNativePath()
```
    Retrieves the String representation of this using the native registry api format.
    
    Returns:
    A String representation for this in native format.
    Since:
    
    1.4
  - toString
```
public String toString()
```
    Retrieve a String representation of this.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    A String representation for this.
  - unLoadKey
```
public int unLoadKey()
```
    Unloads this and all subkeys and values from the registry.
    
    Returns:
    An integer error code which tells if the operation was successful or not. To obtain a description of the error, use formatErrorMessage(int).
    See Also:
    canUnLoadKey()
  - valueExists
```
public boolean valueExists(String value)
```
    Tests to see if the specified value exists under this.
    
    Parameters:
    value - The name of the value whose existence will be tested.
    
    Returns:
    true if the value exists, false otherwise.
  - valueNamesIterator
```
public Iterator<String> valueNamesIterator()
```
    Retrieves an Iterator of Strings which represent the names of the values that are under this. If the values of this are changed from outside the iterator while an iteration is in progress, then a ConcurrentModificationException is thrown. If an error occurs, then null is returned.
    
    Returns:
    An Iterator of Strings that are the names of the values of this or null if an error occurs.
    Since:
    
    1.8
    
    See Also:
    getValue(String), getValueNames(), getValues(), getValues(String...), valuesIterator()
  - valuesIterator
```
public Iterator<RegistryValue> valuesIterator()
```
    Retrieves an Iterator of RegistryValues which represent the values that are under this. If the values of this are changed from outside the iterator while an iteration is in progress, then a ConcurrentModificationException is thrown. If an error occurs, then null is returned.
    
    Returns:
    An Iterator of RegistryValues that are the values of this or null if an error occurs.
    Since:
    
    1.8
    
    See Also:
    getValue(String), getValueNames(), getValues(), getValues(String...), valueNamesIterator()
  - view64BitRegistry
```
public void view64BitRegistry(boolean view64)
```
    Specifies whether the key should look into the 64-bit registry or the 32-bit registry This method does nothing on Windows 2000 systems.
    
    Parameters:
    view64 - true if the key should view the 64-bit part of the registry, false otherwise.
    Since:
    
    1.6

Class RegistryKey

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ERROR_CODE

NUM_SUB_KEYS

MAX_SUB_KEY_LENGTH

MAX_CLASS_LENGTH

NUM_VALUES

MAX_VALUE_NAME_LENGTH

MAX_VALUE_LENGTH

ERROR_SUCCESS

ERROR_FILE_NOT_FOUND

ERROR_ACCESS_DENIED

ERROR_INVALID_HANDLE

ERROR_OUTOFMEMORY

ERROR_INVALID_PARAMETER

ERROR_PROC_NOT_FOUND

ERROR_ALREADY_EXISTS

ERROR_FILENAME_EXCED_RANGE

ERROR_BADDB

ERROR_BADKEY

ERROR_CANTOPEN

ERROR_CANTREAD

ERROR_CANTWRITE

ERROR_REGISTRY_CORRUPT

ERROR_REGISTRY_IO_FAILED

ERROR_NOT_REGISTRY_FILE

ERROR_KEY_DELETED

ERROR_NO_LOG_SPACE

ERROR_KEY_HAS_CHILDREN

ERROR_CHILD_MUST_BE_VOLATILE

ERROR_NO_SYSTEM_RESOURCES

MAX_KEY_LENGTH

MAX_CHARACTER_LENGTH

REG_NOTIFY_CHANGE_NAME

REG_NOTIFY_CHANGE_ATTRIBUTES

REG_NOTIFY_CHANGE_LAST_SET

REG_NOTIFY_CHANGE_SECURITY

DEFAULT_FILTER

ALL_FILTERS

DEFAULT_VALUE_NAME

HKEY_CLASSES_ROOT_INDEX

HKEY_CURRENT_USER_INDEX

HKEY_LOCAL_MACHINE_INDEX

HKEY_USERS_INDEX

HKEY_PERFORMANCE_DATA_INDEX

HKEY_CURRENT_CONFIG_INDEX

HKEY_DYN_DATA_INDEX

OLD_COPY_TREE

OLD_DELETE_TREE

Constructor Detail

RegistryKey

RegistryKey

RegistryKey

RegistryKey

RegistryKey

RegistryKey

RegistryKey

RegistryKey

RegistryKey

RegistryKey

Method Detail

autoExpandEnvironmentVariables

connect

deleteKeys

deleteLinks

expandEnvironmentVariables

formatErrorMessage

getRegistryQuota

getRootKeyForIndex

isAutoExpandEnvironmentVariables

listRoots

parseKey

parseKey

parseKey

canDelete

canDeleteLink