Package org.optaplanner.core.config.util

Class ConfigUtils

  • public class ConfigUtils
extends Object

    • Method Detail

      • newInstance

        public static <T> T newInstance​(Object configBean,
                                String propertyName,
                                Class<T> clazz)
        Create a new instance of clazz from a config's property.

        If the instantiation fails, the simple class name of configBean will be used as the owner of propertyName.

        Intended usage: 

         selectionFilter = ConfigUtils.newInstance(
         config, "filterClass", config.getFilterClass());
        Type Parameters:
        T - the new instance type
        Parameters:
        configBean - the bean holding the clazz to be instantiated
        propertyName - configBean's property holding clazz
        clazz - Class representation of the type T
        Returns:
        new instance of clazz

      • newInstance

        public static <T> T newInstance​(Supplier<String> ownerDescriptor,
                                String propertyName,
                                Class<T> clazz)
        Create a new instance of clazz from a general source.

        If the instantiation fails, the result of ownerDescriptor will be used to describe the owner of propertyName.

        Type Parameters:
        T - the new instance type
        Parameters:
        ownerDescriptor - describes the owner of propertyName
        propertyName - property holding the clazz
        clazz - Class representation of the type T
        Returns:
        new instance of clazz

      • applyCustomProperties

        public static void applyCustomProperties​(Object bean,
                                         String beanClassPropertyName,
                                         Map<String,​String> customProperties,
                                         String customPropertiesPropertyName)

      • inheritConfig

        public static <Config_ extends AbstractConfig<Config_>> Config_ inheritConfig​(Config_ original,
                                                                              Config_ inherited)

      • inheritMergeableListConfig

        public static <Config_ extends AbstractConfig<Config_>> List<Config_> inheritMergeableListConfig​(List<Config_> originalList,
                                                                                                 List<Config_> inheritedList)

      • inheritOverwritableProperty

        public static <T> T inheritOverwritableProperty​(T original,
                                                T inherited)

      • inheritMergeableListProperty

        public static <T> List<T> inheritMergeableListProperty​(List<T> originalList,
                                                       List<T> inheritedList)

      • inheritMergeableMapProperty

        public static <K,​T> Map<K,​T> inheritMergeableMapProperty​(Map<K,​T> originalMap,
                                                                     Map<K,​T> inheritedMap)

      • mergeProperty

        public static <T> T mergeProperty​(T a,
                                  T b)

      • meldProperty

        public static <T> T meldProperty​(T a,
                                 T b)
        A relaxed version of mergeProperty(Object, Object). Used primarily for merging failed benchmarks, where a property remains the same over benchmark runs (for example: dataset problem size), but the property in the failed benchmark isn't initialized, therefore null. When merging, we can still use the correctly initialized property of the benchmark that didn't fail.

        Null-handling:

        • if both properties are null, returns null
        • if only one of the properties is not null, returns that property
        • if both properties are not null, returns mergeProperty(Object, Object)
        Type Parameters:
        T - the type of property a and b
        Parameters:
        a - property a
        b - property b
        Returns:
        sometimes null
        See Also:
        mergeProperty(Object, Object)

      • isEmptyCollection

        public static boolean isEmptyCollection​(Collection<?> collection)

      • ceilDivide

        public static int ceilDivide​(int dividend,
                             int divisor)
        Divides and ceils the result without using floating point arithmetic. For floor division, see Math.floorDiv(long, long).
        Parameters:
        dividend - the dividend
        divisor - the divisor
        Returns:
        dividend / divisor, ceiled
        Throws:
        ArithmeticException - if divisor == 0

      • resolvePoolSize

        public static int resolvePoolSize​(String propertyName,
                                  String value,
                                  String... magicValues)

      • getAllAnnotatedLineageClasses

        public static List<Class<?>> getAllAnnotatedLineageClasses​(Class<?> bottomClass,
                                                           Class<? extends Annotation> annotation)

      • getDeclaredMembers

        public static List<Member> getDeclaredMembers​(Class<?> baseClass)
        Parameters:
        baseClass - never null
        Returns:
        never null, sorted by type (fields before methods), then by AlphabeticMemberComparator.

      • getAllMembers

        public static List<Member> getAllMembers​(Class<?> baseClass,
                                         Class<? extends Annotation> annotationClass)
        Parameters:
        baseClass - never null
        annotationClass - never null
        Returns:
        never null, sorted by type (fields before methods), then by AlphabeticMemberComparator.

      • extractCollectionGenericTypeParameterStrictly

        public static Class<?> extractCollectionGenericTypeParameterStrictly​(String parentClassConcept,
                                                                     Class<?> parentClass,
                                                                     Class<?> type,
                                                                     Type genericType,
                                                                     Class<? extends Annotation> annotationClass,
                                                                     String memberName)

      • extractCollectionGenericTypeParameterLeniently

        public static Class<?> extractCollectionGenericTypeParameterLeniently​(String parentClassConcept,
                                                                      Class<?> parentClass,
                                                                      Class<?> type,
                                                                      Type genericType,
                                                                      Class<? extends Annotation> annotationClass,
                                                                      String memberName)

      • abbreviate

        public static String abbreviate​(List<String> list,
                                int limit)