Package: groovy.util

## [Java] Class ConfigObject

- groovy.util.ConfigObject

- All Implemented Interfaces and Traits:
    Writable, Map, Cloneable

      public class ConfigObject
      extends GroovyObjectSupport
      implements Writable, Map, Cloneable

  A ConfigObject at a simple level is a Map that creates configuration entries (other ConfigObjects) when referencing them. This means that navigating to foo.bar.stuff will not return null but nested ConfigObjects which are of course empty maps The Groovy truth can be used to check for the existence of "real" entries.

  Since:
    1.5

- - ### Constructor Summary

    Constructors
    Constructor and description
    `ConfigObject(URL file)` Creates a config object associated with the supplied source.
    `ConfigObject()` Creates an empty config object with no associated source.

  - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `` | `public void` | `clear()` Removes all of the mappings from this map (optional operation). The map will be empty after this call returns. throws: UnsupportedOperationException if the `clear` operation is not supported by this map
    `` | `public ConfigObject` | `clone()` Returns a shallow copy of this ConfigObject, keys and configuration entries are not cloned.
    `` | `public boolean` | `containsKey(Object key)` Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `Objects.equals(key, k)`. (There can be at most one such mapping.) throws: ClassCastException if the key is of an inappropriate type for this map (optional) throws: NullPointerException if the specified key is null and this map does not permit null keys (optional) Parameters: `key` - key whose presence in this map is to be tested Returns: `true` if this map contains a mapping for the specified key
    `` | `public boolean` | `containsValue(Object value)` Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `Objects.equals(value, v)`. This operation will probably require time linear in the map size for most implementations of the `Map` interface. throws: ClassCastException if the value is of an inappropriate type for this map (optional) throws: NullPointerException if the specified value is null and this map does not permit null values (optional) Parameters: `value` - value whose presence in this map is to be tested Returns: `true` if this map maps one or more keys to the specified value
    `` | `public Set` | `entrySet()` Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation, or through the `setValue` operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations. Returns: a set view of the mappings contained in this map
    `` | `public Map` | `flatten()` A ConfigObject is a tree structure consisting of nested maps.
    `` | `public Map` | `flatten(Map target)` Flattens this ConfigObject populating the results into the target Map
    `` | `public Object` | `get(Object key)` Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key. More formally, if this map contains a mapping from a key `k` to a value `v` such that `Objects.equals(key, k)`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.) If this map permits null values, then a return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The containsKey operation may be used to distinguish these two cases. throws: ClassCastException if the key is of an inappropriate type for this map (optional) throws: NullPointerException if the specified key is null and this map does not permit null keys (optional) Parameters: `key` - the key whose associated value is to be returned Returns: the value to which the specified key is mapped, or `null` if this map contains no mapping for the key
    `` | `public URL` | `getConfigFile()` Returns the config resource that produced this object.
    `` | `public Object` | `getProperty(String name)` Overrides the default getProperty implementation to create nested ConfigObject instances on demand for non-existent keys
    `` | `public boolean` | `isEmpty()` Returns `true` if this map contains no key-value mappings. Returns: `true` if this map contains no key-value mappings
    `` | `public Boolean` | `isSet(String option)` Checks if a config option is set.
    `` | `public Set` | `keySet()` Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations. Returns: a set view of the keys contained in this map
    `` | `public Map` | `merge(ConfigObject other)` Merges the given map with this ConfigObject overriding any matching configuration entries in this ConfigObject
    `` | `public String` | `prettyPrint()` Renders this config object using config-script syntax.
    `` | `public Object` | `put(Object key, Object value)` Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map `m` is said to contain a mapping for a key `k` if and only if containsKey(Object) m.containsKey(k) would return `true`.) throws: UnsupportedOperationException if the `put` operation is not supported by this map throws: ClassCastException if the class of the specified key or value prevents it from being stored in this map throws: NullPointerException if the specified key or value is null and this map does not permit null keys or values throws: IllegalArgumentException if some property of the specified key or value prevents it from being stored in this map Parameters: `key` - key with which the specified value is to be associated `value` - value to be associated with the specified key Returns: the previous value associated with `key`, or `null` if there was no mapping for `key`. (A `null` return can also indicate that the map previously associated `null` with `key`, if the implementation supports `null` values.)
    `` | `public void` | `putAll(Map m)` Copies all of the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling put(Object,Object) put(k, v) on this map once for each mapping from key `k` to value `v` in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress. throws: UnsupportedOperationException if the `putAll` operation is not supported by this map throws: ClassCastException if the class of a key or value in the specified map prevents it from being stored in this map throws: NullPointerException if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values throws: IllegalArgumentException if some property of a key or value in the specified map prevents it from being stored in this map Parameters: `m` - mappings to be stored in this map
    `` | `public Object` | `remove(Object key)` Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `Objects.equals(key, k)`, that mapping is removed. (The map can contain at most one such mapping.) Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key. If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`. The map will not contain a mapping for the specified key once the call returns. throws: UnsupportedOperationException if the `remove` operation is not supported by this map throws: ClassCastException if the key is of an inappropriate type for this map (optional) throws: NullPointerException if the specified key is null and this map does not permit null keys (optional) Parameters: `key` - key whose mapping is to be removed from the map Returns: the previous value associated with `key`, or `null` if there was no mapping for `key`.
    `` | `public void` | `setConfigFile(URL configFile)` Updates the config resource associated with this object.
    `` | `public int` | `size()` Returns the number of key-value mappings in this map. If the map contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`. Returns: the number of key-value mappings in this map
    `` | `public Properties` | `toProperties()` Converts this ConfigObject into the java.util.Properties format, flattening the tree structure beforehand
    `` | `public Properties` | `toProperties(String prefix)` Converts this ConfigObject ino the java.util.Properties format, flatten the tree and prefixing all entries with the given prefix
      > `` | `public String` | `toString()` Returns a string representation of the object. API Note: In general, the `toString` method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method. The string output is not necessarily stable over time or across JVM invocations. Implementation Requirements: The `toString` method for class `Object` returns a string consisting of the name of the class of which the object is an instance, the at-sign character ``@`', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
      >     getClass().getName() + '@' + Integer.toHexString(hashCode())
    Returns: a string representation of the object.
    `` | `public Collection` | `values()` Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations. Returns: a collection view of the values contained in this map
    `` | `public Writer` | `writeTo(Writer outArg)` Writes this config object into a String serialized representation which can later be parsed back using the parse() method

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class GroovyObjectSupport` | `getMetaClass, setMetaClass`

- - ### Constructor Detail

    - #### public ConfigObject(URL file)

      Creates a config object associated with the supplied source.

      Parameters:
        `file` - the parsed config resource, or `null`

    - #### public ConfigObject()

      Creates an empty config object with no associated source.

  - ### Method Detail

    - #### public void clear()

      Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

      throws:
        UnsupportedOperationException if the `clear` operation is not supported by this map

    - #### public ConfigObject clone()

      Returns a shallow copy of this ConfigObject, keys and configuration entries are not cloned.

      Returns:
        a shallow copy of this ConfigObject

    - #### public boolean containsKey(Object key)

      Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `Objects.equals(key, k)`. (There can be at most one such mapping.)

      throws:
        ClassCastException if the key is of an inappropriate type for this map (optional)
      throws:
        NullPointerException if the specified key is null and this map does not permit null keys (optional)
      Parameters:
        `key` - key whose presence in this map is to be tested
      Returns:
        `true` if this map contains a mapping for the specified key

    - #### public boolean containsValue(Object value)

      Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `Objects.equals(value, v)`. This operation will probably require time linear in the map size for most implementations of the `Map` interface.

      throws:
        ClassCastException if the value is of an inappropriate type for this map (optional)
      throws:
        NullPointerException if the specified value is null and this map does not permit null values (optional)
      Parameters:
        `value` - value whose presence in this map is to be tested
      Returns:
        `true` if this map maps one or more keys to the specified value

    - #### public Set entrySet()

      Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation, or through the `setValue` operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.

      Returns:
        a set view of the mappings contained in this map

    - #### public Map flatten()

      A ConfigObject is a tree structure consisting of nested maps. This flattens the maps into a single level structure like a properties file

    - #### public Map flatten(Map target)

      Flattens this ConfigObject populating the results into the target Map

      See Also:
        ConfigObject.flatten

    - #### public Object get(Object key)

      Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.

      More formally, if this map contains a mapping from a key `k` to a value `v` such that `Objects.equals(key, k)`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.)

      If this map permits null values, then a return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The containsKey operation may be used to distinguish these two cases.

      throws:
        ClassCastException if the key is of an inappropriate type for this map (optional)
      throws:
        NullPointerException if the specified key is null and this map does not permit null keys (optional)
      Parameters:
        `key` - the key whose associated value is to be returned
      Returns:
        the value to which the specified key is mapped, or `null` if this map contains no mapping for the key

    - #### public URL getConfigFile()

      Returns the config resource that produced this object.

      Returns:
        the originating config resource, or `null`

    - #### public Object getProperty(String name)

      Overrides the default getProperty implementation to create nested ConfigObject instances on demand for non-existent keys

    - #### public boolean isEmpty()

      Returns `true` if this map contains no key-value mappings.

      Returns:
        `true` if this map contains no key-value mappings

    - #### public Boolean isSet(String option)

      Checks if a config option is set. Example usage:

           def config = new ConfigSlurper().parse("foo { password='' }")
           assert config.foo.isSet('password')
           assert config.foo.isSet('username') == false

      The check works only for options one block below the current block. E.g. `config.isSet('foo.password')` will always return false.
      Parameters:
        `option` - The name of the option
      Returns:
        `true` if the option is set `false` otherwise
      Since:
        2.3.0

    - #### public Set keySet()

      Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations.

      Returns:
        a set view of the keys contained in this map

    - #### public Map merge(ConfigObject other)

      Merges the given map with this ConfigObject overriding any matching configuration entries in this ConfigObject

      Parameters:
        `other` - The ConfigObject to merge with
      Returns:
        The result of the merge

    - #### public String prettyPrint()

      Renders this config object using config-script syntax.

      Returns:
        a formatted config representation

    - #### public Object put(Object key, Object value)

      Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map `m` is said to contain a mapping for a key `k` if and only if containsKey(Object) m.containsKey(k) would return `true`.)

      throws:
        UnsupportedOperationException if the `put` operation is not supported by this map
      throws:
        ClassCastException if the class of the specified key or value prevents it from being stored in this map
      throws:
        NullPointerException if the specified key or value is null and this map does not permit null keys or values
      throws:
        IllegalArgumentException if some property of the specified key or value prevents it from being stored in this map
      Parameters:
        `key` - key with which the specified value is to be associated
        `value` - value to be associated with the specified key
      Returns:
        the previous value associated with `key`, or `null` if there was no mapping for `key`. (A `null` return can also indicate that the map previously associated `null` with `key`, if the implementation supports `null` values.)

    - #### public void putAll(Map m)

      Copies all of the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling put(Object,Object) put(k, v) on this map once for each mapping from key `k` to value `v` in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.

      throws:
        UnsupportedOperationException if the `putAll` operation is not supported by this map
      throws:
        ClassCastException if the class of a key or value in the specified map prevents it from being stored in this map
      throws:
        NullPointerException if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values
      throws:
        IllegalArgumentException if some property of a key or value in the specified map prevents it from being stored in this map
      Parameters:
        `m` - mappings to be stored in this map

    - #### public Object remove(Object key)

      Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `Objects.equals(key, k)`, that mapping is removed. (The map can contain at most one such mapping.)

      Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key.

      If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`.

      The map will not contain a mapping for the specified key once the call returns.

      throws:
        UnsupportedOperationException if the `remove` operation is not supported by this map
      throws:
        ClassCastException if the key is of an inappropriate type for this map (optional)
      throws:
        NullPointerException if the specified key is null and this map does not permit null keys (optional)
      Parameters:
        `key` - key whose mapping is to be removed from the map
      Returns:
        the previous value associated with `key`, or `null` if there was no mapping for `key`.

    - #### public void setConfigFile(URL configFile)

      Updates the config resource associated with this object.

      Parameters:
        `configFile` - the originating config resource

    - #### public int size()

      Returns the number of key-value mappings in this map. If the map contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`.

      Returns:
        the number of key-value mappings in this map

    - #### public Properties toProperties()

      Converts this ConfigObject into the java.util.Properties format, flattening the tree structure beforehand

      Returns:
        A java.util.Properties instance

    - #### public Properties toProperties(String prefix)

      Converts this ConfigObject ino the java.util.Properties format, flatten the tree and prefixing all entries with the given prefix

      Parameters:
        `prefix` - The prefix to append before property entries
      Returns:
        A java.util.Properties instance

    - #### public String toString()

      Returns a string representation of the object.

      API Note:
        In general, the `toString` method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method. The string output is not necessarily stable over time or across JVM invocations.
      Implementation Requirements:
        The `toString` method for class `Object` returns a string consisting of the name of the class of which the object is an instance, the at-sign character ``@`', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:

        >     getClass().getName() + '@' + Integer.toHexString(hashCode())

      Returns:
        a string representation of the object.

    - #### public Collection values()

      Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.

      Returns:
        a collection view of the values contained in this map

    - #### public Writer writeTo(Writer outArg)

      Writes this config object into a String serialized representation which can later be parsed back using the parse() method

      See Also:
        Writable.writeTo