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: 
  * +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+.
  * +getAdapted+ allow accessing any type, hereby also passing a +PropertyAdapter+ that converts
    the configured literal value to the type required.
  * +with, query+ provide the extension points for adding additional functionality.
  
  Additionally +Configuration+ provides several access methods:
  
  [source,java]
  .Interface Configuration
  --------------------------------------------
  public interface Configuration extends PropertySource{
     ...
  
      // accessors for configuration
      public static Configuration current();
      public static Configuration current(String name);
      public static boolean isAvailable(String name);
      // accessors for template and injection
      public static <T> T createTemplate(Class<T> template, Configuration... configurations);
      public static void configure(Object instance, Configuration... configurations);
  }
  --------------------------------------------
  
  Hereby
  * +current()+ returns the _default_ +Configuration+
  * +current(String name)+ returns a named +Configuration+ (there may be arbitrary additional +Configuration+ instance
    additionally to the default +Configuration+ instance.
  * +isAvailable(String name)+ allows to determine if a named +Configuration+ is available.
  * +createTemplate(Class<T> template, Configuration... configurations)+ allows to create a new template instance based
    on a (optionally) annotated interface. The according getter methods are backed up and implemented by Tamaya based
    on the configuration values available. The +configurations+ parameter allows parts of +Configuration+ instances to be
    passed that override any instances available through +current(name), current()+.
  * +configure+ performs injection of configured values on a (optionally) annotated non abstract type.
    The +configurations+ parameter allows parts of +Configuration+ instances to be
    passed that override any instances available through +current(name), current()+.
  
  
  [[TypeConversion]]
  ==== Type Conversion
  
  Configuration extend +PropertySource+ and adds additional support for non String types. This is achieved
  with the help of +PropertyAdapter+ instances:
  
  [source,java]
  .PropertyAdapter
  --------------------------------------------
  @FunctionalInterface
  public interface PropertyAdapter<T>{
      T adapt(String value);
  }
  --------------------------------------------
  
  +PropertyAdapter+ instances can be implemented manually or registered and accessed from the
  +PropertyAdaper+ using static methods. Hereby the exact mechanism is determined by the implementation
  of +PropertyAdapterSpi+ backing up the static methods.
  By default corresponding +PropertyAdapter+ instances can be registered using the Java +ServiceLoader+
  mechanism, or programmatically ba calling the +register(Class, PropertyAdapter)+.
  
  [source,java]
  .PropertyAdapter
  --------------------------------------------
  @FunctionalInterface
  public interface PropertyAdapter<T>{
      T adapt(String value);
  
      public static <T> PropertyAdapter<T> register(Class<T> targetType, PropertyAdapter<T> adapter);
      public static boolean isTargetTypeSupported(Class<?> targetType);
      public static  <T> PropertyAdapter<T> getAdapter(Class<T> targetType);
      public static  <T> PropertyAdapter<T> getAdapter(Class<T> targetType, WithPropertyAdapter annotation);
  }
  --------------------------------------------
  
  The now a typed instance of a +Configuration+ is required, by default the +Configuration+ implementation acquires
  a matching +PropertyAdapter+. If one is found it can easily pass the String value from its String property store
  for converting it to the required target type. In the normal case for the mostly needed types this is completely
  transparent to the user.
  But basically this mechanism can also be used for adaptive filtering of values accessed. As an example lets assume
  we want to decode an encryped password on the fly, so we can achieve this with as less code as follows:
  
  [source,java]
  .Simple Filtering Adapter Use Case
  --------------------------------------------
  Configuration config = Configuration.cuirrent();
  String decryptedPassword = config.getAdapted(String.class, "user.password", p -> PKI.decrypt(p));
  --------------------------------------------
  
  === Extension Points
  
  
negative.code: +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{
      // 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> getOptional(String key, PropertyConverter<T> adapter);
      <T> Optional<T> getOptional(String key, Class<T> type);
  
      public static Configuration current();
  }
  --------------------------------------------
  
  