Package com.evolveum.midpoint.util

Class MiscUtil

java.lang.Object
com.evolveum.midpoint.util.MiscUtil
public class MiscUtil extends Object
Author:
semancik

  • Constructor Details

    • MiscUtil

      public MiscUtil()

  • Method Details

    • union

      @SafeVarargs @NotNull public static <T> @NotNull Collection<T> union(Collection<T>... sets)

    • unionExtends

      @SafeVarargs public static <T> Collection<? extends T> unionExtends(Collection<? extends T>... sets)

    • unorderedCollectionEquals

      public static <T> boolean unorderedCollectionEquals(Collection<? extends T> a, Collection<? extends T> b)

    • unorderedCollectionEqualsWithComparator

      public static <T> boolean unorderedCollectionEqualsWithComparator(Collection<T> a, Collection<T> b, Comparator<T> comparator)
      Only zero vs non-zero value of comparator is important. Prefer other unorderedCollectionEquals whenever possible. If you are provided with comparator for good reason, you may use this. If you create comparator for this method, you probably should create EqualsChecker instead.

    • unorderedCollectionEquals

      public static <A, B> boolean unorderedCollectionEquals(Collection<A> a, Collection<B> b, HeteroEqualsChecker<A,B> comparator)
      Only zero vs non-zero value of comparator is important.

    • unorderedArrayEquals

      public static <T> boolean unorderedArrayEquals(T[] a, T[] b)

    • unorderedArrayEquals

      public static <T> boolean unorderedArrayEquals(T[] a, T[] b, EqualsChecker<T> equalsChecker)
      Only zero vs non-zero value of comparator is important.

    • unorderedCollectionHashcode

      public static <T> int unorderedCollectionHashcode(Collection<T> collection, Predicate<T> filter)

    • readFile

      public static String readFile(File file) throws IOException
      Throws:
      IOException

    • copyFile

      public static void copyFile(File sourceFile, File destFile) throws IOException
      Throws:
      IOException

    • copyDirectory

      public static void copyDirectory(File src, File dst) throws IOException
      Copy a directory and its contents.
      Parameters:
      src - The name of the directory to copy.
      dst - The name of the destination directory.
      Throws:
      IOException - If the directory could not be copied.

    • createCollection

      @SafeVarargs public static <T> Collection<T> createCollection(T... items)

    • and

      public static Boolean and(Boolean... operands)
      n-ary and that ignores null values.

    • equals

      public static boolean equals(Object a, Object b)

    • asXMLGregorianCalendar

      @Nullable public static @Nullable XMLGregorianCalendar asXMLGregorianCalendar(@Nullable @Nullable Date date)
      Converts a java.util.Date into an instance of XMLGregorianCalendar
      Parameters:
      date - Instance of java.util.Date or a null reference
      Returns:
      XMLGregorianCalendar instance whose value is based upon the value in the date parameter. If the date parameter is null then this method will simply return null.

    • asXMLGregorianCalendar

      @Nullable public static @Nullable XMLGregorianCalendar asXMLGregorianCalendar(@Nullable @Nullable Long timeInMillis)
      Returns null for null input, but also for value of 0L.

    • asXMLGregorianCalendar

      @Nullable public static @Nullable XMLGregorianCalendar asXMLGregorianCalendar(@Nullable @Nullable Instant instant)

    • asInstant

      @Nullable public static @Nullable Instant asInstant(@Nullable @Nullable Long millis)

    • asInstant

      @Nullable public static @Nullable Instant asInstant(@Nullable @Nullable XMLGregorianCalendar xgc)

    • asDate

      public static Date asDate(XMLGregorianCalendar xgc)
      Converts an XMLGregorianCalendar to an instance of java.util.Date
      Parameters:
      xgc - Instance of XMLGregorianCalendar or a null reference
      Returns:
      java.util.Date instance whose value is based upon the value in the xgc parameter. If the xgc parameter is null then this method will simply return null.

    • asMillis

      public static Long asMillis(XMLGregorianCalendar xgc)

    • asDate

      public static Date asDate(int year, int month, int date, int hrs, int min, int sec)

    • cartesian

      public static <T> void cartesian(List<? extends Collection<T>> valuesForDimensions, Processor<List<T>> tupleProcessor)
      We have n dimensions (D1...Dn), each containing a number of values.

      This method sequentially creates all n-tuples of these values (one value from each dimension) and invokes tupleProcessor on them.

    • concat

      public static String concat(Collection<String> stringCollection)

    • isAllNull

      public static boolean isAllNull(Collection<?> collection)

    • getValueWithClass

      public static String getValueWithClass(Object object)

    • getDiagInfoLazy

      @Experimental public static Object getDiagInfoLazy(Object o)

    • getDiagInfo

      @Experimental public static String getDiagInfo(Collection<?> objects, int maxItems, int maxLengthPerObject)

    • getDiagInfo

      @Experimental public static String getDiagInfo(Object o)

    • getDiagInfo

      @Experimental public static String getDiagInfo(Object o, int maxLength)

    • q

      @NotNull public static @NotNull String q(@Nullable @Nullable Object value)
      Correctly quotes a string for use in diagnostic messages. TODO maybe we should somehow merge this with getDiagInfo(Object) method

    • getClass

      public static String getClass(Object object)

    • isNoValue

      public static boolean isNoValue(Collection<?> collection)

    • hasNoValue

      public static boolean hasNoValue(Collection<?> collection)

    • cloneMap

      public static <K, V> Map<K,V> cloneMap(Map<K,V> orig)
      Shallow clone

    • toString

      public static String toString(Object o)

    • splitLines

      public static List<String> splitLines(String string)

    • isBetween

      public static boolean isBetween(XMLGregorianCalendar date, XMLGregorianCalendar start, XMLGregorianCalendar end)

    • contains

      public static <T> boolean contains(T element, T[] array)

    • stripHtmlMarkup

      public static String stripHtmlMarkup(String htmlString)

    • getValuesFromDisplayableValues

      public static <T> Collection<T> getValuesFromDisplayableValues(Collection<? extends DisplayableValue<T>> disps)

    • bytesToHex

      @NotNull public static @NotNull String bytesToHex(@NotNull @org.jetbrains.annotations.NotNull byte[] bytes)

    • hexToBytes

      public static byte[] hexToBytes(String hex)

    • bytesToHexPreview

      @Nullable public static @Nullable String bytesToHexPreview(@Nullable @org.jetbrains.annotations.Nullable byte[] bytes)
      Returns first 8 bytes from provided byte array as hexadecimal and adds length information. Returns null if null array is provided.

    • bytesToHexPreview

      @Nullable public static @Nullable String bytesToHexPreview(@Nullable @org.jetbrains.annotations.Nullable byte[] bytes, int previewLen)
      Returns a couple of bytes from provided byte array as hexadecimal and adds length information. Returns null if null array is provided.
      Parameters:
      previewLen - max number of bytes in the hexadecimal preview

    • hexToUtf8String

      public static String hexToUtf8String(String hex)

    • addAllIfNotPresent

      public static <T> void addAllIfNotPresent(List<T> receivingList, List<T> supplyingList)

    • addIfNotPresent

      public static <T> void addIfNotPresent(List<T> receivingList, T supplyingElement)

    • nullableCollectionsEqual

      public static boolean nullableCollectionsEqual(Collection<?> c1, Collection<?> c2)

    • getObjectName

      public static String getObjectName(Object o)

    • compareNullLast

      public static Integer compareNullLast(Object o1, Object o2)

    • orElseGet

      public static <T> T orElseGet(T value, Supplier<T> supplier)
      As Objects.requireNonNullElseGet(Object, Supplier) but does not require the supplier to provide non-null value.

    • getFirstNonNull

      @SafeVarargs public static <T> T getFirstNonNull(T... values)

    • getFirstNonNullRequired

      @SafeVarargs @NotNull public static <T> T getFirstNonNullRequired(T... values)

    • getFirstNonNullFromList

      public static <T> T getFirstNonNullFromList(List<T> values)

    • getFirstNonNullString

      public static String getFirstNonNullString(Object... values)

    • first

      @SafeVarargs @NotNull public static <T> T first(T value, Supplier<T>... suppliers)

    • extractSingleton

      public static <T> T extractSingleton(Collection<T> collection)

    • extractSingleton

      public static <T, E extends Throwable> T extractSingleton(Collection<T> collection, Supplier<E> exceptionSupplier) throws E
      Throws:
      E extends Throwable

    • extractSingleton

      public static <T, E extends Throwable> T extractSingleton(Collection<T> collection, Predicate<T> predicate, Supplier<E> exceptionSupplier) throws E
      Throws:
      E extends Throwable

    • extractSingletonRequired

      @NotNull public static <T, E extends Throwable> T extractSingletonRequired(Collection<T> collection, Supplier<E> multiExceptionSupplier, Supplier<E> noneExceptionSupplier) throws E
      Throws:
      E extends Throwable

    • extractSingletonRequired

      @NotNull public static <T, E extends Throwable> T extractSingletonRequired(@Nullable @Nullable Collection<T> collection, @Nullable @Nullable Predicate<T> predicate, @NotNull @NotNull Supplier<E> multiExceptionSupplier, @NotNull @NotNull Supplier<E> noneExceptionSupplier) throws E
      Throws:
      E extends Throwable

    • extractSingletonRequired

      @NotNull public static <T> T extractSingletonRequired(Collection<T> collection)

    • extractSingletonRequired

      @NotNull public static <T> T extractSingletonRequired(@Nullable @Nullable Collection<T> collection, @Nullable @Nullable Predicate<T> predicate)

    • getSingleValue

      public static <T> T getSingleValue(Collection<T> values, T defaultValue, String contextDescription)

    • isCollectionOf

      public static boolean isCollectionOf(Object object, @NotNull @NotNull Class<?> memberClass)

    • instancesOf

      public static <E> Function<Object,Stream<E>> instancesOf(Class<E> cls)

    • last

      public static <T> T last(List<T> list)

    • emptyIfNull

      @NotNull public static @NotNull String emptyIfNull(String s)

    • emptyIfNull

      @NotNull public static <T> @NotNull List<T> emptyIfNull(List<T> list)

    • emptyIfNull

      @NotNull public static <K, V> @NotNull Map<K,V> emptyIfNull(Map<K,V> map)

    • emptyIfNull

      @NotNull public static <T> @NotNull Collection<T> emptyIfNull(Collection<T> collection)

    • streamOf

      @NotNull public static <T> @NotNull Stream<T> streamOf(Collection<T> collection)

    • nullIfEmpty

      public static String nullIfEmpty(String s)

    • nullIfBlank

      public static String nullIfBlank(String s)

    • hasDuplicates

      public static <T> boolean hasDuplicates(Collection<T> collection)
      Returns true if the collection contains at least one pair of equals elements.

    • formatExceptionMessageWithCause

      public static String formatExceptionMessageWithCause(Throwable t)

    • formatExceptionMessageWithCause

      public static String formatExceptionMessageWithCause(Throwable t, int indent)

    • formatExceptionMessage

      public static String formatExceptionMessage(Throwable t)

    • throwException

      public static <T extends Throwable> void throwException(Throwable exception) throws T
      Throws:
      T extends Throwable

    • throwExceptionAsUnchecked

      public static void throwExceptionAsUnchecked(Throwable t)

    • runChecked

      public static <T> T runChecked(CheckedFunction<Producer<T>,T> function, CheckedProducer<T> checkedProducer) throws CommonException
      Throws:
      CommonException

    • unwrapTunnelledException

      public static <T> void unwrapTunnelledException(TunnelException te) throws CommonException
      Throws:
      CommonException

    • unwrapTunnelledExceptionToRuntime

      public static <T> void unwrapTunnelledExceptionToRuntime(TunnelException te)

    • filter

      public static <T> Collection<T> filter(Collection<T> input, Predicate<? super T> predicate)

    • filter

      public static <T> Set<T> filter(Set<T> input, Predicate<? super T> predicate)

    • nonNullValues

      @NotNull public static <V> @NotNull Collection<V> nonNullValues(@NotNull @NotNull Collection<V> values)

    • toUrlUnchecked

      public static URL toUrlUnchecked(URI uri)

    • join

      public static <T> List<T> join(Collection<T> a, Collection<T> b)

    • takeThreadDump

      public static String takeThreadDump(@Nullable @Nullable Thread thread)
      Thanks for this code go to https://crunchify.com/how-to-generate-java-thread-dump-programmatically/

    • paramsToMap

      public static <K, V> Map<K,V> paramsToMap(Object[] params)

    • writeZipFile

      public static void writeZipFile(File file, String entryName, String content, Charset charset) throws IOException
      Throws:
      IOException

    • readZipFile

      public static String readZipFile(File file, Charset charset) throws IOException
      Throws:
      IOException

    • singletonOrEmptySet

      public static <T> Set<T> singletonOrEmptySet(T value)

    • singletonOrEmptyList

      public static <T> List<T> singletonOrEmptyList(T value)

    • castSafely

      public static <T> T castSafely(Object value, Class<T> expectedClass) throws SchemaException
      Throws:
      SchemaException

    • castSafely

      public static <T> T castSafely(Object value, Class<T> expectedClass, Object errorCtx) throws SchemaException
      Throws:
      SchemaException

    • determineCommonAncestor

      public static Class<?> determineCommonAncestor(Collection<Class<?>> classes)

    • throwAsSame

      @Experimental public static <T extends Throwable> void throwAsSame(Throwable original, String message) throws T
      Re-throws the original exception wrapped in the same class (e.g. SchemaException as SchemaException) but with additional message. It is used to preserve meaning of the exception but adding some contextual information.
      Throws:
      T extends Throwable

    • createSame

      @Experimental public static <T extends Throwable> T createSame(T original, String message)

    • getEarliestTimeIgnoringNull

      public static XMLGregorianCalendar getEarliestTimeIgnoringNull(Collection<XMLGregorianCalendar> realValues)

    • findWithComparator

      public static <V> V findWithComparator(Collection<V> values, V value, @NotNull @NotNull Comparator<V> comparator)

    • find

      public static <V> V find(Collection<V> values, V value, @NotNull @NotNull EqualsChecker<V> equalsChecker)

    • enumFromOrdinal

      public static <T extends Enum<T>> T enumFromOrdinal(Class<T> enumType, Integer ordinal)
      Converts integer ordinal number to enum value of the defined enum type.
      Parameters:
      enumType - type of enum (class object)
      ordinal - ordinal value
      Returns:
      enum value or null if ordinal is null
      Throws:
      IndexOutOfBoundsException - If the ordinal value is out of enum value range

    • enumOrdinal

      @Nullable public static @Nullable Integer enumOrdinal(@Nullable @Nullable Enum<?> enumValue)
      Returns ordinal value from nullable enum or returns null.

    • trimString

      @Nullable public static @Nullable String trimString(@Nullable @Nullable String value, int size)

    • getSimpleClassName

      public static String getSimpleClassName(Object o)

    • requireNonNull

      public static <T> T requireNonNull(T value, Supplier<String> messageSupplier) throws SchemaException
      Throws:
      SchemaException

    • requireNonNull

      public static <T> T requireNonNull(T value, String template, Object... arguments) throws SchemaException
      Throws:
      SchemaException

    • configNonNull

      public static <T> T configNonNull(T value, Supplier<String> messageSupplier) throws ConfigurationException
      Throws:
      ConfigurationException

    • configNonNull

      public static <T> T configNonNull(T value, String template, Object... arguments) throws ConfigurationException
      Throws:
      ConfigurationException

    • argNonNull

      public static <T> T argNonNull(T value, Supplier<String> messageSupplier)

    • argNonNull

      public static <T> T argNonNull(T value, String template, Object... arguments)

    • stateNonNull

      public static <T> T stateNonNull(T value, Supplier<String> messageSupplier)

    • stateNonNull

      public static <T> T stateNonNull(T value, String template, Object... arguments)

    • assertNonNull

      public static <T> T assertNonNull(T value, String template, Object... arguments)

    • stateNonEmpty

      public static <C extends Collection<?>> C stateNonEmpty(C collection, String template, Object... arguments)

    • isSingleNull

      public static boolean isSingleNull(Object[] values)

    • sleepWatchfully

      public static void sleepWatchfully(long until, long increment, Supplier<Boolean> canRunSupplier)
      Sleeps watching "can run" flag. InterruptedException is caught (causing checking can run flag) but not propagated.

    • sleepCatchingInterruptedException

      public static void sleepCatchingInterruptedException(long delay)
      Sleeps for specified time. InterruptedException is caught (causing immediate exit) but not propagated.

    • sleepNonInterruptibly

      public static void sleepNonInterruptibly(long delay)
      Sleeps for specified time. InterruptedException is ignored - after we get it, we simply continue sleeping, until the whole specified time elapses. This is e.g. to simulate non-interruptible execution of a task.

    • getRandomItem

      public static <T> T getRandomItem(List<T> collection)

    • toLong

      public static Long toLong(Integer value)

    • toInteger

      public static Integer toInteger(Long value)

    • resolvePrimitiveIfNecessary

      public static Class<?> resolvePrimitiveIfNecessary(Class<?> aClass)
      Resolves primitive type like `int` to wrapper, like `Integer`.

    • exceptNulls

      public static <T> T[] exceptNulls(T[] nullable)

    • requireNonNull

      public static <T, E extends Throwable> T requireNonNull(T value, MiscUtil.ExceptionSupplier<E> exceptionSupplier) throws E
      Throws:
      E extends Throwable

    • checkCollectionImmutable

      public static void checkCollectionImmutable(Collection<?> collection)

    • schemaCheck

      public static void schemaCheck(boolean condition, String template, Object... arguments) throws SchemaException
      Throws:
      SchemaException

    • configCheck

      public static void configCheck(boolean condition, String template, Object... arguments) throws ConfigurationException
      Throws:
      ConfigurationException

    • stateCheck

      public static void stateCheck(boolean condition, String template, Object... arguments)

    • assertCheck

      public static void assertCheck(boolean condition, String template, Object... arguments)

    • argCheck

      public static void argCheck(boolean condition, String template, Object... arguments)

    • getClassWithMessage

      public static String getClassWithMessage(Throwable e)

    • asListTreatingNull

      public static <T> List<T> asListTreatingNull(T[] values)
      Like Arrays.asList(Object[]) but if there's a single null value at input, creates an empty list.

    • asListExceptForNull

      @Experimental @SafeVarargs @NotNull public static <T> @NotNull List<? extends T> asListExceptForNull(T... values)
      Fixed version of asListTreatingNull(Object[]) that returns "extends T" list, and filters out all non-null values.

    • asListExceptForNull

      @Deprecated public static <T> List<T> asListExceptForNull()
      Deprecated.

    • asListExceptForNull

      @Experimental @NotNull public static <T> @NotNull List<T> asListExceptForNull(T value)
      Separate method for efficiency

    • or0

      public static BigDecimal or0(BigDecimal value)

    • or0

      public static int or0(Integer value)

    • or0

      public static long or0(Long value)

    • or0

      public static double or0(Double value)

    • min

      public static Integer min(Integer a, Integer b)

    • min

      public static Long min(Long a, Long b)

    • max

      public static Integer max(Integer a, Integer b)

    • max

      public static Long max(Long a, Long b)

    • startsWith

      public static boolean startsWith(List<?> wholeList, List<?> subList)

    • fixFileName

      public static String fixFileName(String originalName)
      Crude attempt at replacing all illegal chars with underscores. Maybe too strict.

    • concat

      @NotNull public static <T> @NotNull Collection<? extends T> concat(@NotNull @NotNull Collection<? extends T> collection1, @NotNull @NotNull Collection<? extends T> collection2)
      Returns a concatenation of two collections. (No trying to remove multiplicities.) Optimizing the operation if one of collections is empty. The return value should not be used for modifications!