Package ch.kk7.confij

Class ConfijBuilder<T>

  • public class ConfijBuilder<T>
extends java.lang.Object

    • Constructor Detail

      • ConfijBuilder

        protected ConfijBuilder​(@NonNull
                        @NonNull java.lang.reflect.Type forType)

    • Method Detail

      • lazySetDefaults

        protected void lazySetDefaults()

      • of

        public static <X> ConfijBuilder<X> of​(java.lang.Class<X> forClass)
        The most common constructor to create a new configuration builder of given type.
        Type Parameters:
        X - the configuration instance type
        Parameters:
        forClass - the configuration instance class
        Returns:
        a ConfiJ builder

      • of

        public static <X> ConfijBuilder<X> of​(GenericType<X> forType)
        This constructor is used to pass full generics type information, and avoid problems with type erasure (that basically removes most usable type references from runtime Class objects).
        Type Parameters:
        X - the configuration instance type
        Parameters:
        forType - type holder class
        Returns:
        a ConfiJ builder
        See Also:
        GenericType

      • loadFrom

        public ConfijBuilder<T> loadFrom​(ConfijSource... source)
        Read configuration values from these ordered sources. Intended for more complex scenarios, where loadFrom(String...) isn't good enough.
        Parameters:
        source - list of configuration sources
        Returns:
        self

      • loadFrom

        public ConfijBuilder<T> loadFrom​(java.lang.String... sourceStr)
        Read configuration values from these ordered AnySources.
        Parameters:
        sourceStr - list of path's to configuration sources
        Returns:
        self

      • loadFrom

        public ConfijBuilder<T> loadFrom​(ConfijResource... resources)
        Read configuration values from these ordered resources (like from FS, git,...). The format of the content is guessed.
        Parameters:
        resources - list of resources (like files,...) to read configurations from
        Returns:
        self

      • loadFrom

        public ConfijBuilder<T> loadFrom​(ConfijResource resource,
                                 ConfijFormat format)
        Read configuration values from a well defined source and format. Equivalent to loadFrom(ConfijSource...).
        Parameters:
        resource - resource (like files,...) to read configurations from
        format - the actual format which understants the content of resource
        Returns:
        self

      • loadOptionalFrom

        public ConfijBuilder<T> loadOptionalFrom​(java.lang.String... maybeSourceStr)
        Attempt reading configurationd from all of these ordered AnySources. Read failures are dropped silently. Usefull for optional configuration, like for tests only.
        Parameters:
        maybeSourceStr - optional sources, reading all of them is attempted
        Returns:
        self
        See Also:
        MaybeSource

      • loadFromFirstOf

        public ConfijBuilder<T> loadFromFirstOf​(java.lang.String firstSource,
                                        java.lang.String secondSource,
                                        java.lang.String... otherSources)
        Attempt reading configurations from these ordered AnySources. Ignore all configurations before and after the first successful read. Usefull if a set of configurations should be ignored if another one is present.
        Parameters:
        firstSource - an optional source
        secondSource - an optional source
        otherSources - more optional sources, only read if not an earlier one existed
        Returns:
        self
        See Also:
        OrSource

      • validateOnlyWith

        public ConfijBuilder<T> validateOnlyWith​(@NonNull
                                         @NonNull ConfijValidator<T> validator)
        replace the default validation/post-processing steps with this new validator. The default is to load all ServiceLoaders implementing ConfijValidator. To combine multiple validators use a MultiValidator.
        Parameters:
        validator - the new validator
        Returns:
        self

      • validationAllowsNull

        public ConfijBuilder<T> validationAllowsNull()

      • templatingDisabled

        public ConfijBuilder<T> templatingDisabled()
        disables templating (variable substitution), such that your values containing ${variables} just stay as they are.
        Returns:
        self

      • bindValuesForClassWith

        public <I> ConfijBuilder<T> bindValuesForClassWith​(ValueMapperInstance<I> valueMapper,
                                                   java.lang.Class<I> forClass)
        Convenience method to register a ValueMapperFactory which will only handle a single class.
        Type Parameters:
        I - the target type
        Parameters:
        valueMapper - functional interface to convert a string to I
        forClass - the class of I
        Returns:
        self

      • reloadStrategy

        public ConfijBuilder<T> reloadStrategy​(@NonNull
                                       @NonNull ConfijReloadStrategy reloadStrategy)
        define when/how new configurations are loaded. default is a NeverReloadStrategy.
        Parameters:
        reloadStrategy - the new reload strategy to be used
        Returns:
        self

      • reloadPeriodically

        public ConfijBuilder<T> reloadPeriodically​(@NonNull
                                           @NonNull java.time.Duration duration)
        A PeriodicReloadStrategy with initial delay equal to interval duration
        Parameters:
        duration - time between reload attempts
        Returns:
        self

      • newBindingContext

        @NonNull
protected @NonNull BindingContext newBindingContext()

      • newNodeBindingContext

        @NonNull
protected @NonNull NodeBindingContext newNodeBindingContext()

      • newPipeline

        @NonNull
protected @NonNull ConfijPipeline<T> newPipeline()

      • build

        public T build()
        Finalize the configuration pipeline and build a single instance of it. In cases where you enable periodic configuration reloading, use buildWrapper() instead.
        Returns:
        a fully initialized configuration instance

      • buildWrapper

        public ConfijBuilder.ConfijWrapper<T> buildWrapper()
        Finalize the configuration pipeline and build a single instance holding the most recent configuration. In cases where no periodic configuration reload strategy is defined, build() is simpler to use instead.
        Returns:
        a wrapper with the most up-to-date instance and ways to register reload notification hooks.