Interface StrategySelector

    • Method Detail

      • registerStrategyImplementor

        <T> void registerStrategyImplementor​(Class<T> strategy,
                                             String name,
                                             Class<? extends T> implementation)
        Registers a named implementor of a particular strategy contract.
        Type Parameters:
        T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
        Parameters:
        strategy - The strategy contract.
        name - The registration name
        implementation - The implementation Class
      • unRegisterStrategyImplementor

        <T> void unRegisterStrategyImplementor​(Class<T> strategy,
                                               Class<? extends T> implementation)
        Un-registers a named implementor of a particular strategy contract. Un-registers all named registrations for the given strategy contract naming the given class.
        Type Parameters:
        T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
        Parameters:
        strategy - The strategy contract.
        implementation - The implementation Class
      • selectStrategyImplementor

        <T> Class<? extends T> selectStrategyImplementor​(Class<T> strategy,
                                                         String name)
        Locate the named strategy implementation.
        Type Parameters:
        T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
        Parameters:
        strategy - The type of strategy to be resolved.
        name - The name of the strategy to locate; might be either a registered name or the implementation FQN.
        Returns:
        The named strategy implementation class.
      • resolveStrategy

        <T> T resolveStrategy​(Class<T> strategy,
                              Object strategyReference)
        Resolve strategy instances. See discussion on resolveDefaultableStrategy(java.lang.Class<T>, java.lang.Object, T). Only difference is that here, the implied default value is null.
        Type Parameters:
        T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
        Parameters:
        strategy - The type (interface) of the strategy to be resolved.
        strategyReference - The reference to the strategy for which we need to resolve an instance.
        Returns:
        The strategy instance
      • resolveDefaultableStrategy

        <T> T resolveDefaultableStrategy​(Class<T> strategy,
                                         Object strategyReference,
                                         T defaultValue)
        Resolve strategy instances. The incoming reference might be:
        • null - in which case defaultValue is returned.
        • An actual instance of the strategy type - it is returned, as is
        • A reference to the implementation Class - an instance is created by calling Class.newInstance() (aka, the class's no-arg ctor).
        • The name of the implementation class - First the implementation's Class reference is resolved, and then an instance is created by calling Class.newInstance()
        Type Parameters:
        T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
        Parameters:
        strategy - The type (interface) of the strategy to be resolved.
        strategyReference - The reference to the strategy for which we need to resolve an instance.
        defaultValue - THe default value to use if strategyReference is null
        Returns:
        The strategy instance
      • resolveDefaultableStrategy

        <T> T resolveDefaultableStrategy​(Class<T> strategy,
                                         Object strategyReference,
                                         Callable<T> defaultResolver)
        Resolve strategy instances. The incoming reference might be:
        • null - in which case defaultValue is returned.
        • An actual instance of the strategy type - it is returned, as is
        • A reference to the implementation Class - an instance is created by calling Class.newInstance() (aka, the class's no-arg ctor).
        • The name of the implementation class - First the implementation's Class reference is resolved, and then an instance is created by calling Class.newInstance()
        Type Parameters:
        T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
        Parameters:
        strategy - The type (interface) of the strategy to be resolved.
        strategyReference - The reference to the strategy for which we need to resolve an instance.
        defaultResolver - A strategy for resolving the default value strategyReference resolves to null.
        Returns:
        The strategy instance
      • resolveStrategy

        <T> T resolveStrategy​(Class<T> strategy,
                              Object strategyReference,
                              T defaultValue,
                              StrategyCreator<T> creator)
      • getRegisteredStrategyImplementors

        <T> Collection<Class<? extends T>> getRegisteredStrategyImplementors​(Class<T> strategy)
        Retrieve all of the registered implementors of the given strategy. Useful to allow defaulting the choice to the single registered implementor when only one is registered
        Returns:
        The implementors. Should never return null