Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.eclipse.core.runtime.preferences
Interface IPreferencesService

public interface IPreferencesService

The preference service provides facilities for dealing with the default scope precedence lookup order, querying the preference store for values using this order, accessing the root of the preference store node hierarchy, and importing/exporting preferences.

The default-default preference search look-up order as defined by the plaform is: project, instance, configuration, default.

This interface is not intended to be implemented by clients.

Since:
  3.0

Method Summary
`IStatus` | `applyPreferences(IExportedPreferences preferences)` Take the given preference tree and apply it to the Eclipse global preference hierarchy.
`IStatus` | `exportPreferences(IEclipsePreferences node, OutputStream output, String[] excludesList)` Exports all preferences for the given preference node and all its children to the specified output stream.
`String` | `get(String key, String defaultValue, Preferences[] nodes)` Lookup the given key in the specified preference nodes in the given order.
`boolean` | `getBoolean(String qualifier, String key, boolean defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`byte[]` | `getByteArray(String qualifier, String key, byte[] defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`String[]` | `getDefaultLookupOrder(String qualifier, String key)` Return an array with the default lookup order for the preference keyed by the given qualifier and simple name.
`double` | `getDouble(String qualifier, String key, double defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`float` | `getFloat(String qualifier, String key, float defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`int` | `getInt(String qualifier, String key, int defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`long` | `getLong(String qualifier, String key, long defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`String[]` | `getLookupOrder(String qualifier, String key)` Return an array with the lookup order for the preference keyed by the given qualifier and simple name.
`IEclipsePreferences` | `getRootNode()` Return the root node of the Eclipse preference hierarchy.
`String` | `getString(String qualifier, String key, String defaultValue, IScopeContext[] contexts)` Return the value stored in the preference store for the given key.
`IStatus` | `importPreferences(InputStream input)` Loads preferences from the given file and stores them in the preferences store.
`IExportedPreferences` | `readPreferences(InputStream input)` Read from the given input stream and create a node hierarchy representing the preferences and their values.
`void` | `setDefaultLookupOrder(String qualifier, String key, String[] order)` Set the default scope lookup order for the preference keyed by the given qualifier and simple name.

Method Detail

### get

    public String get(String key,
                      String defaultValue,
                      Preferences[] nodes)

  Lookup the given key in the specified preference nodes in the given order. Return the value from the first node the key is found in. If the key is not defined in any of the given nodes, then return the specified default value.

  Immediately returns the default value if the node list is `null`. If any of the individual entries in the node list are `null` then skip over them and move on to the next node in the list.

  Parameters:
    `key` - the preference key
    `defaultValue` - the default value
    `nodes` - the list of nodes to search, or null
  Returns:
    the stored preference value or the specified default value
  See Also:
    `Preferences`

### getBoolean

    public boolean getBoolean(String qualifier,
                              String key,
                              boolean defaultValue,
                              IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getByteArray

    public byte[] getByteArray(String qualifier,
                               String key,
                               byte[] defaultValue,
                               IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getDouble

    public double getDouble(String qualifier,
                            String key,
                            double defaultValue,
                            IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getFloat

    public float getFloat(String qualifier,
                          String key,
                          float defaultValue,
                          IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getInt

    public int getInt(String qualifier,
                      String key,
                      int defaultValue,
                      IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getLong

    public long getLong(String qualifier,
                        String key,
                        long defaultValue,
                        IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getString

    public String getString(String qualifier,
                            String key,
                            String defaultValue,
                            IScopeContext[] contexts)

  Return the value stored in the preference store for the given key. If the key is not defined then return the specified default value. Use the canonical scope lookup order for finding the preference value.

  The semantics of this method are to calculate the appropriate `Preferences` nodes in the preference hierarchy to use and then call the `get(String, String, Preferences[])` method. The order of the nodes is calculated by consulting the default scope lookup order as set by `setDefaultLookupOrder(String, String, String[])`.

  The specified key may either refer to a simple key or be the concatenation of the path of a child node and key. If the key contains a slash ("/") character, then a double-slash must be used to denote the end of they child path and the beginning of the key. Otherwise it is assumed that the key is the last segment of the path. The following are some examples of keys and their meanings:

  - "a" - look for a value for the property "a"
  - "//a" - look for a value for the property "a"
  - "///a" - look for a value for the property "/a"
  - "//a//b" - look for a value for the property "a//b"
  - "a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b/c" - look in the child node "a/b" for property "a"
  - "/a/b//c" - look in the child node "a/b" for the property "c"
  - "a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c/d" - look in the child node "a/b" for the property "c/d"
  - "/a/b//c//d" - look in the child node "a/b" for the property "c//d"

  Callers may specify an array of scope context objects to aid in the determination of the correct nodes. For each entry in the lookup order, the array of contexts is consulted and if one matching the scope exists, then it is used to calculate the node. Otherwise a default calculation algorithm is used.

  An example of a qualifier for an Eclipse 2.1 preference is the plug-in identifier. (e.g. "org.eclipse.core.resources" for "description.autobuild")

  Parameters:
    `qualifier` - a namespace qualifier for the preference
    `key` - the name of the preference (optionally including its path)
    `defaultValue` - the value to use if the preference is not defined
    `contexts` - optional context objects to help scopes determine which nodes to search, or `null`
  Returns:
    the value of the preference or the given default value
  See Also:
    `IScopeContext`, `get(java.lang.String, java.lang.String, org.osgi.service.prefs.Preferences[])`, `getLookupOrder(java.lang.String, java.lang.String)`, `getDefaultLookupOrder(java.lang.String, java.lang.String)`

### getRootNode

    public IEclipsePreferences getRootNode()

  Return the root node of the Eclipse preference hierarchy.

  Returns:
    the root of the hierarchy

### exportPreferences

    public IStatus exportPreferences(IEclipsePreferences node,
                                     OutputStream output,
                                     String[] excludesList)
                              throws CoreException

  Exports all preferences for the given preference node and all its children to the specified output stream. It is the responsibility of the client to close the given output stream.

  If the given export list is `null` then all preferences for all subnodes of the given node are exported to the given stream. Otherwise the export list is consulted before exporting each preference value. If there is a string match then the preference is not exported. The exclusion can also occur at a per-node level. Wildcards are not accepted in the excludes list as a basic String compare is done. The basic algorithm is similar to the following:

       String fullPath = node.absolutePath() + '/' + key;
       if (!fullPath.startsWith(excludesList[i]))
       	// export preference

  The values stored in the resulting stream are suitable for later being read by the by `importPreferences(InputStream)` or `readPreferences(InputStream)` methods.

  Parameters:
    `node` - the node to treat as the root of the export
    `output` - the stream to write to
    `excludesList` - a list of path prefixes to exclude from the export, or `null`
  Returns:
    a status object describing success or detailing failure reasons
  Throws:
    `CoreException` - if there was a problem exporting the preferences
    `IllegalArgumentException` - if the node or stream is `null`
  See Also:
    `importPreferences(java.io.InputStream)`, `readPreferences(InputStream)`

### importPreferences

    public IStatus importPreferences(InputStream input)
                              throws CoreException

  Loads preferences from the given file and stores them in the preferences store. Existing values are over-ridden by those from the stream. The stream must not be `null` and is closed upon return from this method.

  This file must have been written by the `exportPreferences(IEclipsePreferences, OutputStream, String[])` method.

  This method is equivalent to calling `applyPreferences(readPreferences(input));`.

  Parameters:
    `input` - the stream to load the preferences from
  Returns:
    a status object describing success or detailing failure reasons
  Throws:
    `CoreException` - if there are problems importing the preferences
    `IllegalArgumentException` - if the stream is `null`
  See Also:
    `exportPreferences(IEclipsePreferences, OutputStream, String[])`

### applyPreferences

    public IStatus applyPreferences(IExportedPreferences preferences)
                             throws CoreException

  Take the given preference tree and apply it to the Eclipse global preference hierarchy. If a node is an export root, then remove it from the global tree before adding any preferences contained in it or its children. The given preferences object must not be `null`.

  Parameters:
    `preferences` - the preferences to apply globally
  Returns:
    status object indicating sucess or failure
  Throws:
    `IllegalArgumentException` - if the preferences are `null`
    `CoreException` - if there are problems applying the preferences

### readPreferences

    public IExportedPreferences readPreferences(InputStream input)
                                         throws CoreException

  Read from the given input stream and create a node hierarchy representing the preferences and their values. The given input stream must not be `null`. The result of this function is suitable for passing as an argument to `applyPreferences(IExportedPreferences)`.

  It is assumed the contents of the input stream have been written by `exportPreferences(IEclipsePreferences, OutputStream, String[])`.

  Parameters:
    `input` - the input stream to read from
  Returns:
    the node hierarchy representing the stream contents
  Throws:
    `IllegalArgumentException` - if the given stream is null
    `CoreException` - if there are problems reading the preferences
  See Also:
    `exportPreferences(IEclipsePreferences, OutputStream, String[])`, `applyPreferences(IExportedPreferences)`

### getDefaultLookupOrder

    public String[] getDefaultLookupOrder(String qualifier,
                                          String key)

  Return an array with the default lookup order for the preference keyed by the given qualifier and simple name. Return `null` if no default has been set.

  The lookup order returned is based on an exact match to the specified qualifier and simple name. For instance, if the given key is non-`null` and no default lookup order is found, the default lookup order for the qualifier (and a `null` key) is NOT returned. Clients should call `getLookupOrder(String, String)` if they desire this behavior.

  Parameters:
    `qualifier` - the namespace qualifier for the preference
    `key` - the preference name or `null`
  Returns:
    the scope order or `null`
  See Also:
    `setDefaultLookupOrder(String, String, String[])`, `getLookupOrder(String, String)`

### getLookupOrder

    public String[] getLookupOrder(String qualifier,
                                   String key)

  Return an array with the lookup order for the preference keyed by the given qualifier and simple name.

  First do an exact match lookup with the given qualifier and simple name. If a match is found then return it. Otherwise if the key is non-`null` then do a lookup based on only the qualifier and return the set value. Return the default-default order as defined by the platform if no order has been set.

  Parameters:
    `qualifier` - the namespace qualifier for the preference
    `key` - the preference name or `null`
  Returns:
    the scope order
  Throws:
    `IllegalArgumentException` - if the qualifier is `null`
  See Also:
    `getDefaultLookupOrder(String, String)`, `setDefaultLookupOrder(String, String, String[])`

### setDefaultLookupOrder

    public void setDefaultLookupOrder(String qualifier,
                                      String key,
                                      String[] order)

  Set the default scope lookup order for the preference keyed by the given qualifier and simple name. If the given order is `null` then the set ordering (if it exists) is removed.

  If the given simple name is `null` then set the given lookup order to be used for all keys with the given qualifier.

  Note that the default lookup order is not persisted across platform invocations.

  Parameters:
    `qualifier` - the namespace qualifier for the preference
    `key` - the preference name or `null`
    `order` - the lookup order or `null`
  Throws:
    `IllegalArgumentException` -
    - if the qualifier is `null`
    - if an entry in the order array is `null` (the array itself is allowed to be `null`
  See Also:
    `getDefaultLookupOrder(String, String)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Guidelines for using Eclipse APIs.

Copyright (c) IBM Corp. and others 2000, 2004. All rights reserved.