anchor.diff:       *** 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
  +  ** _PropertySourceProvider:_ allows to add property sources dynamically.
     ** +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.
  +  ** +ServiceContextManager+ provides static access to the +ServiceContext+ loaded..
   
   This is also reflected in the main parts of the API, which is quite small:
   
  
positive.code: +Configuration+ inherits all basic features from +PropertySource+, but additionally adds functionality for
  type safety and external features of any interacting with configuration:
  
  [source,java]
  .Interface Configuration
  --------------------------------------------
  public interface Configuration extends PropertySource{
      // type 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);
  }
  --------------------------------------------
  
  
negative.code: 
  * +XXX getXXX(String)+ provide type safe accessors for all basic wrapper types of the JDK. Basically all this
    methods delegate to the +getAdapted+ method, additionally passing the required +PropertyAdapter+.
  * +get(String, PropertyConverter)+ allow accessing any type, hereby also passing a +PropertyConverter+ that converts
    the configured literal value to the type required.
  * +with, query+ provide the extension points for adding additional functionality.
  * +current()+ returns the _default_ +Configuration+
  
  
  [[TypeConversion]]
  ==== Type Conversion (PropertyConverter)
  
  Configuration extend +PropertySource+ and adds additional support for non String types. This is achieved
  with the help of +PropertyConverter+ instances:
  
  [source,java]
  .PropertyConverter
  --------------------------------------------
  // @FunctionalInterface
  public interface PropertyConverter<T>{
      T convert(String value);
  }
  --------------------------------------------
  
  +PropertyConverter+ instances can be implemented and registered by default using the +ServiceLoader+.
  Access to converters is given by the +ConfigurationContext+.
  
  [[PropertySourceProvider]]
  ==== Property Source Provider
  
  Instances of this type can be used to register a multiple collection of +PropertySource+ instances at one
  dynamically.
  
  [source,java]
  .PropertySourceProvider
  --------------------------------------------
  // @FunctionalInterface
  public interface PropertySourceProvider{
      Collection<PropertySource> getPropertySources();
  }
  --------------------------------------------
  
  This allows to evaluate the property sources to be read dynamically, when the system is loading.
  
  [[PropertyFilters]]
  ==== Property Value Filtering
  
  Also filters can be registered (by default) using the +ServiceLoader+. Filters allow to replace or remove values
  provided by the underlying property sources. A filter is defined as follows:
  
  [source,java]
  .PropertyFilter
  --------------------------------------------
  // @FunctionalInterface
  public interface PropertyConverter{
      String filterProperty(String key, String valueToBeFiltered);
  }
  --------------------------------------------
  
  This method is called each time a single entry is accessed, and for each property in a full properties result.
  For enabling multiple resolution steps, filtering is done multiple times, until no further value change could
  be registered.
  
  === Extension Points
  
  