Module io.helidon.config.mp
Package io.helidon.config.mp

Class MpConfigProviderResolver.ConfigDelegate

  • All Implemented Interfaces:
    Config, Config
    Enclosing class:
    MpConfigProviderResolver
    @Deprecated(since="2.3.1")
public static final class MpConfigProviderResolver.ConfigDelegate
extends Object
implements Config, Config
    Deprecated.
    This is an internal class that was exposed accidentally. It will be package local in next major release.
    A delegate used to allow replacing configuration at runtime for components that hold a reference to configuration obtained at build time.

    • Method Detail

      • timestamp

        public Instant timestamp()
        Deprecated.
        Description copied from interface: Config
        Returns when the configuration tree was created.

        Each config node of single Config tree returns same timestamp.

        Specified by:
        timestamp in interface Config
        Returns:
        timestamp of created instance of whole configuration tree.
        See Also:
        Config.context(), Config.Context.timestamp()

      • key

        public Config.Key key()
        Deprecated.
        Description copied from interface: Config
        Returns the fully-qualified key of the Config node.

        The fully-qualified key is a sequence of tokens derived from the name of each node along the path from the config root to the current node. Tokens are separated by . (the dot character). See Config.name() for more information on the format of each token.

        Specified by:
        key in interface Config
        Returns:
        current config node key
        See Also:
        Config.name()

      • get

        public Config get​(Config.Key key)
        Deprecated.
        Description copied from interface: Config
        Returns the single sub-node for the specified sub-key.
        Specified by:
        get in interface Config
        Parameters:
        key - sub-key of requested sub-node
        Returns:
        config node for specified sub-key, never returns null.
        See Also:
        Config.get(String)

      • detach

        public Config detach()
        Deprecated.
        Description copied from interface: Config
        Returns a copy of the Config node with no parent.

        The returned node acts as a root node for the subtree below it. Its key is the empty string; "". The original config node is unchanged, and the original and the copy point to the same children.

        Consider the following configuration: 

         app:
      name: Example 1
      page-size: 20
 logging:
      app.level = INFO
      level = WARNING
        The Config instances name1 and name2 represents same data and in fact refer to the same object: 
         Config name1 = config
                  .get("app")
                  .get("name");
 Config name2 = config
                  .get("app")
                  .detach()               //DETACHED node
                  .get("name");

 assert name1.asString() == "Example 1";
 assert name2.asString() == "Example 1";  //DETACHED node
        The only difference is the key each node returns: 
         assert name1.key() == "app.name";
 assert name2.key() == "name";            //DETACHED node

        See Config.asMap() for example of config detaching.

        Specified by:
        detach in interface Config
        Returns:
        returns detached Config instance of same config node

      • type

        public Config.Type type()
        Deprecated.
        Description copied from interface: Config
        Provides the Config.Type of the Config node.
        Specified by:
        type in interface Config
        Returns:
        the Type of the configuration node

      • hasValue

        public boolean hasValue()
        Deprecated.
        Description copied from interface: Config
        Returns true if this configuration node has a direct value.

        This may be a value node (e.g. a leaf) or object node or a list node (e.g. a branch with value). The application can invoke methods such as Config.as(Class) on nodes that have value.

        Specified by:
        hasValue in interface Config
        Returns:
        true if the node has direct value, false otherwise.

      • traverse

        public Stream<Config> traverse​(Predicate<Config> predicate)
        Deprecated.
        Description copied from interface: Config
        Iterative deepening depth-first traversal of the node and its subtree as a Stream<Config>, qualified by the specified predicate.

        If the config node does not exist or is a leaf the returned stream is empty.

        Depending on the structure of the configuration the returned stream can deliver a mix of object, list, and leaf value nodes. The stream will include and traverse through object members and list elements.

        The traversal continues as long as the specified predicate evaluates to true. When the predicate evaluates to false the node being traversed and its subtree will be excluded from the returned Stream<Config>.

        Specified by:
        traverse in interface Config
        Parameters:
        predicate - predicate evaluated on each visited Config node to continue or stop visiting the node
        Returns:
        stream of deepening depth-first subnodes

      • convert

        public <T> T convert​(Class<T> type,
                     String value)
        Deprecated.
        Description copied from interface: Config
        Convert a String to a specific type. This is a helper method to allow for processing of default values that cannot be typed (e.g. in annotations).
        Specified by:
        convert in interface Config
        Type Parameters:
        T - type
        Parameters:
        type - type of the property
        value - String value
        Returns:
        instance of the correct type
        See Also:
        Config.as(Class)

      • as

        public <T> ConfigValue<T> as​(GenericType<T> genericType)
        Deprecated.
        Description copied from interface: Config
        Typed value as a ConfigValue for a generic type. If appropriate mapper exists, returns a properly typed generic instance.

        Example: 

         
 ConfigValue<Map<String, Integer>> myMapValue = config.as(new GenericType<Map<String, Integer>>(){});
 myMapValue.ifPresent(map -> {
      Integer port = map.get("service.port");
  }
        Specified by:
        as in interface Config
        Type Parameters:
        T - type of the returned value
        Parameters:
        genericType - a (usually anonymous) instance of generic type to prevent type erasure
        Returns:
        properly typed config value

      • asList

        public <T> ConfigValue<List<T>> asList​(Class<T> type)
        Deprecated.
        Description copied from interface: Config
        Returns list of specified type.
        Specified by:
        asList in interface Config
        Type Parameters:
        T - type of list elements
        Parameters:
        type - type class
        Returns:
        a typed list with values

      • asList

        public <T> ConfigValue<List<T>> asList​(Function<Config,​T> mapper)
        Deprecated.
        Description copied from interface: Config
        Returns this node as a list converting each list value using the provided mapper.
        Specified by:
        asList in interface Config
        Type Parameters:
        T - type of list elements
        Parameters:
        mapper - mapper to convert each list node into a typed value
        Returns:
        a typed list with values

      • asMap

        public ConfigValue<Map<String,​String>> asMap()
        Deprecated.
        Description copied from interface: Config
        Transform all leaf nodes (values) into Map instance.

        Fully qualified key of config node is used as a key in returned Map. Detach config node before transforming to Map in case you want to cut current Config node key prefix.

        Let's say we work with following configuration: 

         app:
      name: Example 1
      page-size: 20
 logging:
      app.level = INFO
      level = WARNING
        Map app1 contains two keys: app.name, app.page-size. 
        
 Map<String, String> app1 = config.get("app").asMap();
        Detaching app config node returns new Config instance with "reset" local root. 
        
 Map<String, String> app2 = config.get("app").detach().asMap();
        Map app2 contains two keys without app prefix: name, page-size.
        Specified by:
        asMap in interface Config
        Returns:
        new Map instance that contains all config leaf node values
        See Also:
        Config.traverse(), Config.detach()

      • mapper

        public ConfigMapper mapper()
        Deprecated.
        Description copied from interface: Config
        The mapper used by this config instance.
        Specified by:
        mapper in interface Config
        Returns:
        configuration mapper

      • getValue

        public <T> T getValue​(String propertyName,
                      Class<T> propertyType)
        Deprecated.
        Specified by:
        getValue in interface Config

      • delegate

        public Config delegate()
        Deprecated.
        Get the underlying instance of this delegate pattern.
        Returns:
        the instance backing this config delegate