Class MapConfiguration

  • All Implemented Interfaces:
    java.lang.Cloneable, Configuration, EventSource, ImmutableConfiguration, SynchronizerSupport
    Direct Known Subclasses:
    EnvironmentConfiguration, SystemConfiguration

    public class MapConfiguration
    extends AbstractConfiguration
    implements java.lang.Cloneable

    A Map based Configuration.

    This implementation of the Configuration interface is initialized with a java.util.Map. The methods of the Configuration interface are implemented on top of the content of this map. The following storage scheme is used:

    Property keys are directly mapped to map keys, i.e. the getProperty() method directly performs a get() on the map. Analogously, setProperty() or addProperty() operations write new data into the map. If a value is added to an existing property, a java.util.List is created, which stores the values of this property.

    An important use case of this class is to treat a map as a Configuration allowing access to its data through the richer interface. This can be a bit problematic in some cases because the map may contain values that need not adhere to the default storage scheme used by typical configuration implementations, e.g. regarding lists. In such cases care must be taken when manipulating the data through the Configuration interface, e.g. by calling addProperty(); results may be different than expected.

    The handling of list delimiters is a bit different for this configuration implementation: When a property of type String is queried, it is passed to the current ListDelimiterHandler which may generate multiple values. Note that per default a list delimiter handler is set which does not do any list splitting, so this feature is disabled. It can be enabled by setting a properly configured ListDelimiterHandler implementation, e.g. a DefaultListDelimiterHandler object.

    Notice that list splitting is only performed for single string values. If a property has multiple values, the single values are not split even if they contain the list delimiter character.

    As the underlying Map is directly used as store of the property values, the thread-safety of this Configuration implementation depends on the map passed to the constructor.

    Notes about type safety: For properties with multiple values this implementation creates lists of type Object and stores them. If a property is assigned another value, the value is added to the list. This can cause problems if the map passed to the constructor already contains lists of other types. This should be avoided, otherwise it cannot be guaranteed that the application might throw ClassCastException exceptions later.

    Since:
    1.1
    • Field Detail

      • map

        protected java.util.Map<java.lang.String,​java.lang.Object> map
        The Map decorated by this configuration.
    • Constructor Detail

      • MapConfiguration

        public MapConfiguration​(java.util.Map<java.lang.String,​?> map)
        Create a Configuration decorator around the specified Map. The map is used to store the configuration properties, any change will also affect the Map.
        Parameters:
        map - the map
      • MapConfiguration

        public MapConfiguration​(java.util.Properties props)
        Creates a new instance of MapConfiguration which uses the specified Properties object as its data store. All changes of this configuration affect the given Properties object and vice versa. Note that while Properties actually implements Map<Object, Object>, we expect it to contain only string keys. Other key types will lead to ClassCastException exceptions on certain methods.
        Parameters:
        props - the Properties object defining the content of this configuration
        Since:
        1.8
    • Method Detail

      • getMap

        public java.util.Map<java.lang.String,​java.lang.Object> getMap()
        Return the Map decorated by this configuration.
        Returns:
        the map this configuration is based onto
      • isTrimmingDisabled

        public boolean isTrimmingDisabled()
        Returns the flag whether trimming of property values is disabled.
        Returns:
        true if trimming of property values is disabled; false otherwise
        Since:
        1.7
      • setTrimmingDisabled

        public void setTrimmingDisabled​(boolean trimmingDisabled)
        Sets a flag whether trimming of property values is disabled. This flag is only evaluated if list splitting is enabled. Refer to the header comment for more information about list splitting and trimming.
        Parameters:
        trimmingDisabled - a flag whether trimming of property values should be disabled
        Since:
        1.7
      • getPropertyInternal

        protected java.lang.Object getPropertyInternal​(java.lang.String key)
        Description copied from class: AbstractConfiguration
        Actually obtains the value of the specified property. This method is called by getProperty(). Concrete subclasses must define it to fetch the value of the desired property.
        Specified by:
        getPropertyInternal in class AbstractConfiguration
        Parameters:
        key - the key of the property in question
        Returns:
        the (raw) value of this property
      • addPropertyDirect

        protected void addPropertyDirect​(java.lang.String key,
                                         java.lang.Object value)
        Description copied from class: AbstractConfiguration
        Adds a key/value pair to the Configuration. Override this method to provide write access to underlying Configuration store.
        Specified by:
        addPropertyDirect in class AbstractConfiguration
        Parameters:
        key - key to use for mapping
        value - object to store
      • isEmptyInternal

        protected boolean isEmptyInternal()
        Description copied from class: AbstractConfiguration
        Actually checks whether this configuration contains data. This method is called by isEmpty(). It has to be defined by concrete subclasses.
        Specified by:
        isEmptyInternal in class AbstractConfiguration
        Returns:
        true if this configuration contains no data, false otherwise
      • containsKeyInternal

        protected boolean containsKeyInternal​(java.lang.String key)
        Description copied from class: AbstractConfiguration
        Actually checks whether the specified key is contained in this configuration. This method is called by containsKey(). It has to be defined by concrete subclasses.
        Specified by:
        containsKeyInternal in class AbstractConfiguration
        Parameters:
        key - the key in question
        Returns:
        true if this key is contained in this configuration, false otherwise
      • clearPropertyDirect

        protected void clearPropertyDirect​(java.lang.String key)
        Description copied from class: AbstractConfiguration
        Removes the specified property from this configuration. This method is called by clearProperty() after it has done some preparations. It must be overridden in sub classes.
        Specified by:
        clearPropertyDirect in class AbstractConfiguration
        Parameters:
        key - the key to be removed
      • getKeysInternal

        protected java.util.Iterator<java.lang.String> getKeysInternal()
        Description copied from class: AbstractConfiguration
        Actually creates an iterator for iterating over the keys in this configuration. This method is called by getKeys(), it has to be defined by concrete subclasses.
        Specified by:
        getKeysInternal in class AbstractConfiguration
        Returns:
        an Iterator with all property keys in this configuration
      • sizeInternal

        protected int sizeInternal()
        Description copied from class: AbstractConfiguration
        Actually calculates the size of this configuration. This method is called by size() with a read lock held. The base implementation provided here calculates the size based on the iterator returned by getKeys(). Sub classes which can determine the size in a more efficient way should override this method.
        Overrides:
        sizeInternal in class AbstractConfiguration
        Returns:
        the size of this configuration (i.e. the number of keys)
      • clone

        public java.lang.Object clone()
        Returns a copy of this object. The returned configuration will contain the same properties as the original. Event listeners are not cloned.
        Overrides:
        clone in class BaseEventSource
        Returns:
        the copy
        Since:
        1.3
      • toString

        public java.lang.String toString()
        Converts this object to a String suitable for debugging and logging.
        Overrides:
        toString in class java.lang.Object
        Since:
        2.3