anchor.diff:  +Configuration+ inherits all basic features from +PropertySource+, but additionally adds functionality for
   type safety and external features of any interacting with configuration:
   
  +==== Configuration (Java 7)
  +
  +The minimal API defined for Java version earlier than Java 8 looks as follows:
  +
   [source,java]
   .Interface Configuration
   --------------------------------------------
  +public interface Configuration{
  +    String get(String key);
  +    <T> T get(String key, Class<T> type);
  +    Map<String,String> getProperties();
  +
  +    // extension points
  +    default Configuration with(ConfigOperator operator);
  +    default <T> T query(ConfigQuery<T> query);
  +}
  +--------------------------------------------
  +
  +Hereby
  +
  +* +<T> T get(String, Class<T>)+ provides type safe accessors for all basic wrapper types of the JDK. Basically all this
  +  methods delegate to the +get(String, PropertyConverter)+ method, additionally passing the required +PropertyConverter+.
  +* +get(String, PropertyConverter)+ allow accessing any type, hereby also passing a +PropertyConverter+ explicitly
  +  that converts  the configured literal value to the type required.
  +* +with, query+ provide the extension points for adding additional functionality.
  +* +getProperties()+ provides access to all key/values.
  +
  +
  +==== Configuration (Java 8)
  +
  +The API for Java 8 adds additional support for optionals:
  +
  +[source,java]
  +.Interface Configuration
  +--------------------------------------------
   public interface Configuration extends PropertySource{
  -    // type support
  +    // java 7 inherited methods
  +    String get(String key);
  +    <T> T get(String key, Class<T> type);
  +    Map<String,String> getProperties();
  +
  +    // extension points
  +    default Configuration with(ConfigOperator operator);
  +    default <T> T query(ConfigQuery<T> query);
  +
  +    // new java 8 optional support
       default Optional<Boolean> getBoolean(String key);
       default OptionalInt getInteger(String key);
       default OptionalLong getLong(String key);
       default OptionalDouble getDouble(String key);
  -    default <T> Optional<T> getAdapted(String key, PropertyAdapter<T> adapter);
  -    <T> Optional<T> get(String key, Class<T> type);
  -
  -    // extension points
  -    default Configuration with(UnaryOperator<Configuration> operator);
  -    default <T> T query(ConfigQuery<T> query);
  +    default <T> Optional<T> getOptional(String key, PropertyConverter<T> adapter);
  +    <T> Optional<T> getOptional(String key, Class<T> type);
  +
  +    public static Configuration current();
   }
   --------------------------------------------
   
  
positive.code:      *** is designed as a minimalistic data interface to be implemented by any kind of data providers (local or remote)
       *** provides data key/value pairs in raw format as String key/values only
       *** can optionally support scanning of its provided values
    ** +PropertyConverter+, which defines conversion of String values into any required target types.
    ** +PropertyFilter+, which allows filtering of property values prior getting returned to the caller.
    ** +ConfigurationContext+, which provides the container that contains the property sources and filters that form a
       configuration.
    ** +ServiceContext+, which provides access to the components loaded, depending on the current runtime stack.
  
  This is also reflected in the main parts of the API, which is quite small:
  
  
negative.code:      _Configuration_ provides
       *** access to literal key/value pairs.
       *** functional extension points (+with,query+) based un +UnaryOperator<Configuration>+ (operator) and +Function<Configuration,T>+ (query).
    ** +ConfigProvider+ provides static access to the current +Configuration+ (default configuration)
    ** +ConfigException+ defines a runtime exception for usage by the configuration system.
  
  * Additionally the *SPI* provides:
  