@Test public void testDateToString() { assertEquals("01/01/1901", BaseUtils.dateToString(new Date(1, 0, 1))); assertEquals("03/12/2001", BaseUtils.dateToString(new Date(101, 11, 3))); assertEquals("14/10/2012", BaseUtils.dateToString(new Date(112, 9, 14))); assertEquals("01.01.1901", BaseUtils.dateToString("dd.MM.yyyy", new Date(1, 0, 1))); assertEquals("03.12.2001", BaseUtils.dateToString("dd.MM.yyyy", new Date(101, 11, 3))); assertEquals("14.10.2012", BaseUtils.dateToString("dd.MM.yyyy", new Date(112, 9, 14))); }
public static String dateToString(Date d) { return dateToString("dd/MM/yyyy", d); }
BaseUtils { public static String dateToString(Date d) { return dateToString("dd/MM/yyyy", d); } }
BaseUtils { public static String dateToString(Date d) { return dateToString("dd/MM/yyyy", d); }  }
BaseUtils { public static String dateToString(Date d) { return dateToString("dd/MM/yyyy", d); }  static Integer getApiVersion(); static String getPlatformVersion(); static String checkClientVersion(String serverPlatformVersion, Integer serverApiVersion, String clientPlatformVersion, Integer clientApiVersion); static boolean nullEquals(Object obj1, Object obj2); static int nullCompareTo(Comparable obj1, Comparable obj2); static boolean nullHashEquals(Object obj1, Object obj2); static int nullHash(Object obj); static boolean findByReference(Collection<T> col, Object obj); static boolean[] convertArray(Boolean[] array); static boolean mapEquals(Map<KA, VA> mapA, Map<KB, VB> mapB, Map<KA, KB> mapAB); static Map<K, V> nullJoin(Map<K, ? extends E> map, Map<E, V> joinMap); static Map<K, V> join(Map<K, ? extends E> map, Map<E, V> joinMap); static Map<K, E> joinKeep(Map<K, ? extends E> map, Map<E, E> joinMap); static Map<K, V> rightJoin(Map<K, E> map, Map<R, V> joinMap); static Map<VA, VB> rightCrossJoin(Map<K, VA> map, Map<K, VB> joinMap); static Map<VA, VB> rightNullCrossJoin(Map<K, VA> map, Map<K, VB> joinMap); static List<Map<K, V>> joinCol(Map<K, ? extends E> map, Collection<Map<E, V>> list); static List<V> mapList(List<? extends K> list, ImMap<K, ? extends V> map); static List<K> mapList(Integer[] mapList, List<K> list); static OrderedMap<K, V> mapOrder(List<? extends K> list, Map<K, ? extends V> map); static OrderedMap<V, E> mapOrder(OrderedMap<K, E> list, Map<K, ? extends V> map); static Set<V> mapSet(Set<K> set, Map<K, ? extends V> map); static Map<K, V> innerJoin(Map<K, ? extends E> map, Map<? extends E, V> joinMap); static Map<K, V> nullInnerJoin(Map<K, ? extends E> map, Map<? extends E, V> joinMap); static OrderedMap<K, V> innerJoin(OrderedMap<K, E> map, Map<E, V> joinMap); static Map<K, F> filterValues(Map<K, V> map, Collection<F> values); static Collection<K> filterValues(Map<K, V> map, V value); static Map<K, V> filterInclKeys(Map<BK, V> map, Set<? extends K> keys); static Map<K, V> filterKeys(Map<BK, V> map, Iterable<? extends K> keys); static Map<K, V> filterKeys(Map<BK, V> map, FunctionSet<K> filter, Class<K> aClass); static Map<K, V> filterKeys(Iterable<BK> keys, Map<K, V> map); static Map<K, V> filterInclKeys(Map<BK, V> map, Iterable<? extends K> keys); static Iterable<E> filterIterable(final Iterable<E> iterable, final FunctionSet<E> filter); static Map<K, CV> filterClass(Map<K, V> map, Class<CV> cvClass); static Map<K, V> filterNotKeys(Map<K, V> map, Collection<? extends K> keys); static Map<K, V> filterNotKeys(Map<K, V> map, FunctionSet<T> keys, Class<T> aClass); static Map<K, V> filterNotValues(Map<K, V> map, Collection<? extends V> values); static Collection<K> filter(Collection<K> col, Collection<BK> filter); static List<K> filterList(List<K> list, ImSet<K> filter); static List<K> filterList(List<K> list, Collection<K> filter); static List<K> filterNotList(List<K> list, Collection<K> filter); static Set<K> filterSet(Set<K> set, Collection<K> filter); static Set<K> filterNotSet(Set<K> set, Collection<K> filter); static Collection<K> filterNot(Collection<K> col, Collection<BK> filter); static Map<K, V> splitKeys(Map<BK, V> map, HSet<K> keys, Map<BK, V> rest); static Map<K, V> splitValues(Map<K, BV> map, Collection<V> keys, Map<K, BV> rest); static Map<K, V> mergeEquals(Map<K, V> full, Map<K, V> part); static Map<V, K> reverse(Map<K, V> map); static Map<V, K> reverse(Map<K, V> map, boolean ignoreUnique); static Map<VA, VB> crossJoin(Map<K, VA> map, Map<K, VB> mapTo); static Map<VA, VB> crossJoin(Map<KA, VA> map, Map<KB, VB> mapTo, Map<KA, KB> mapJoin); static Map<KA, KB> crossValues(Map<KA, V> map, Map<KB, V> mapTo); static Map<KA, KB> rightCrossValues(Map<KA, V> map, Map<KB, V> mapTo); static Map<KA, KB> crossInnerValues(Map<KA, V> map, Map<KB, V> mapTo); static Map<KA, KB> crossValues(Map<KA, V> map, Map<KB, V> mapTo, boolean ignoreUnique); static Map<T, VA> splitInnerJoin(Map<T, K> mapTo, Map<K, VA> map1, Map<K, VB> map2, Map<T, VB> res2); static Collection<K> join(Collection<K> col1, Collection<K> col2); static boolean identity(Map<K, V> map); static Map<K, K> toMap(Set<K> collection); static Map<K, K> toMap(Collection<K> collection); static Map<K, V> toMap(List<K> from, List<V> to); static Map<Object, K> toObjectMap(Set<K> collection); static Map<K, V> toMap(Collection<K> collection, V value); static Map<Integer, K> toMap(List<K> list); static OrderedMap<K, V> toOrderedMap(List<? extends K> list, V value); static Map<Integer, K> toMap(K[] list); static List<K> toList(Map<Integer, K> map); static Object deserializeObject(byte[] state); static Object deserializeObject(DataInputStream inStream); static String deserializeString(DataInputStream inStream); static byte[] serializeObject(Object value); static void serializeObject(DataOutputStream outStream, Object object); static byte[] serializeCustomObject(Object object); static Object deserializeCustomObject(byte[] bytes); static void serializeString(DataOutputStream outStream, String str); static void serializeBigDecimal(DataOutputStream outStream, BigDecimal number); static BigDecimal deserializeBigDecimal(DataInputStream inStream); static boolean startsWith(char[] string, int off, char[] check); static Map<K, V> removeKeys(Map<K, V> map, Collection<K> remove); static Map<K, V> removeKey(Map<K, V> map, K remove); static Collection<K> add(Collection<? extends K> col, K add); static Set<K> addSet(Set<? extends K> col, K add); static List<K> add(List<K> col, K add); static Map<K, V> add(Map<? extends K, ? extends V> map, K add, V addValue); static List<K> add(K add, List<? extends K> col); static Collection<K> remove(Collection<? extends K> set, Collection<? extends K> remove); static Collection<K> remove(Collection<? extends K> set, K remove); static List<K> remove(List<? extends K> set, int remove); static Set<K> removeSet(Set<? extends K> set, Collection<? extends K> remove); static List<K> removeList(List<K> list, Collection<K> remove); static List<K> removeList(List<K> list, K remove); static List<K> removeList(List<K> list, int index); static K lastSetElement(Set<K> set); static void moveElement(List<K> list, K elemFrom, K elemTo); static void moveElement(List<K> list, K elemFrom, int index); static LinkedHashMap<B, V> mergeLinked(LinkedHashMap<K1, ? extends V> map1, LinkedHashMap<K2, ? extends V> map2); static Map<B, V> merge(Map<K1, ? extends V> map1, Map<K2, ? extends V> map2); static Map<B, V> override(Map<K1, ? extends V> map1, Map<K2, ? extends V> map2); static Map<K1, V> replace(Map<K1, ? extends V> map1, Map<K2, ? extends V> map2); static Map<K1, V> replaceValues(Map<K1, ? extends V> map1, Map<? extends V, ? extends V> map2); static Map<K, V> replace(Map<K, ? extends V> map, K key, V value); static boolean isSubMap(Map<? extends K, ? extends V> map1, Map<K, ? extends V> map2); static Collection<B> merge(Collection<K1> col1, Collection<K2> col2); static Set<B> mergeSet(Set<K1> set1, Set<K2> set2); static Set<B> mergeColSet(Collection<K1> set1, Collection<K2> set2); static Set<B> mergeItem(Set<K1> set, K2 item); static List<B> addList(B item, List<? extends B> list); static List<B> mergeList(List<? extends B> list1, List<? extends B> list2); @SafeVarargs static List<B> mergeLists(List<B>... lists); static Map<Object, EV> mergeMaps(Map<V, EV> map, Map<MV, EV> toMerge, Map<MV, Object> mergedMap); static List<List<T>> cartesianProduct(List<List<T>> data); static K findDeadEnd(Map<K, K> map, K end); static boolean equalArraySets(T[] array1, T[] array2); static int hashSet(T[] array); static T nvl(T value1, T value2); static BigDecimal nvl(BigDecimal value1, Double value2); static String evl(String primary, String secondary); static String nevl(String primary, String secondary); static boolean hashEquals(Object obj1, Object obj2); static boolean contains(T[] array, T element); static boolean contains(T[] array, T element, int num); static Set<T> toSet(T... array); static T getRandom(List<T> list, Random randomizer); static String clause(String clause, String data); static OrderedMap<T, K> orderMap(Map<T, K> map, Iterable<T> list); static List<T> orderList(Set<T> map, Iterable<BT> list); static OrderedMap<K, V> mergeOrders(OrderedMap<K, V> map1, OrderedMap<K, V> map2); static Map<V, V> mergeMaps(Map<V, V>[] maps); static void replaceListElements(List<T> list, T from, T to); static boolean replaceListElements(List<T> list, ImMap<T, T> to); static Long nullToZero(Long value); static Object nullZero(String str); static Object nullString(String str); static String nullToString(Object str); static Object nullBoolean(Boolean b); static Integer nullParseInt(String s); static Integer parseInt(String value); static String replaceSeparators(String value, char separator, char groupingSeparator); static String replaceCommaSeparator(String value); static String replaceDotSeparator(String value); static void clearNotKeys(Map<K, V> map, FunctionSet<T> keep, Class<T> aClass); static double nullAdd(Double p1, Double p2); static Map<G, Collection<K>> group(Group<G, K> getter, Iterable<K> keys); static Map<G, List<K>> groupList(Group<G, K> getter, List<K> keys); static Map<G, Set<K>> groupSet(Group<G, K> getter, Collection<K> keys); static Map<G, Set<K>> groupSet(final Map<K, G> getter, Set<K> keys); static Map<G, List<K>> groupList(final Map<K, G> getter, List<K> keys); static Map<G, Set<K>> groupSet(final Map<K, G> getter); static Map<G, Set<K>> groupSet(final HMap<K, G> getter, Collection<K> keys); static Map<G, List<K>> groupList(final OrderedMap<K, G> getter); static SortedMap<G, Set<K>> groupSortedSet(Group<G, K> getter, Collection<K> keys, Comparator<? super G> comparator); static SortedMap<G, Set<K>> groupSortedSet(final Map<K, G> getter, Comparator<? super G> comparator); static SortedMap<G, Set<K>> groupSortedSet(final Map<K, G> getter); static Map<K, Integer> multiSet(Collection<K> col); static V addValue(Map<V, V> values, V value); static void putNotNull(K key, Map<K, V> from, Map<K, V> to); static boolean hashContainsValue(Map<K, V> map, V value); static String toString(Collection<K> array, String separator); static String toString(String separator, K... array); static boolean containsAll(Map<K, V> map, Map<K, V> contains); static Map<K, String> mapString(Collection<K> col); static Integer[] toObjectArray(int[] a); static Integer[] toOneBasedArray(int[] a); static Object[] add(Object element, Object[] array1); static Object[] add(Object[] array1, Object element); static Object[] add(Object[] array1, Object[] array2); static Object[] add(List<Object[]> list); static T[] add(T[] array1, T[] array2, ArrayInstancer<T> instancer); static T[] add(List<T> list1, T[] array2, ArrayInstancer<T> instancer); static T[] addElement(T[] array, T element, Class<T> elementClass); static T[] addElement(T element, T[] array, Class<T> elementClass); static T[] addElement(T[] array, T element, ArrayInstancer<T> instancer); static T[] addElement(T element, T[] array, ArrayInstancer<T> instancer); static int[] addInt(int[] array, int element); static T[] removeElement(T[] array, T element, ArrayInstancer<T> instancer); static T[] genArray(T element, int length, ArrayInstancer<T> instancer); static String[] genArray(String element, int length); static int[] genArray(int element, int length); static List<E> immutableCast(List<I> list); static Map<K, E> immutableCast(Map<K, I> map); static I immutableCast(Object object); static String tab(String tab); static String tabPrefix(String tab, String prefix); static I single(Collection<I> col); static I single(Iterable<I> col); static I single(I[] array); static I singleKey(Map<I, ?> map); static I singleValue(Map<?, I> map); static Map.Entry<K, I> singleEntry(Map<K, I> map); static List<K> reverse(List<K> col); static List<K> toList(Iterable<K> col); static List<K> reverse(Iterable<K> col); static List<K> reverseThis(List<K> col); static int objectToInt(Integer value); static Integer intToObject(int value); static String nullTrim(String string); static String nullEmpty(String string); static String rtrim(String string); static String toCaption(Object name); static Map<K, V> buildMap(Collection<K> col1, Collection<V> col2); @SafeVarargs static List<K> toList(K... elements); static List<K> toListNoNull(K... elements); static String replicate(char character, int length); static String truncate(String s, int length); static String padRight(String s, int n); static String padLeft(String s, int n); static String capitalize(String s); static boolean isRedundantString(String s); static boolean isRedundantString(Object o); static String spaces(int count); static String padr(String string, int length); static String padl(String string, int length); static String padl(String string, int length, char character); static int countRepeatingChars(String string, char character, int index); static K last(List<K> list); static int relativePosition(K element, List<K> comparatorList, List<K> insertList); static int[] relativeIndexes(List<T> all, List<T> list); static List<K> copyTreeChildren(List children); static HashComponents<K> getComponents(HashInterface<K, C> hashInterface); static boolean onlyObjects(Iterable<?> col); static ImRevMap<T, Object> generateObjects(ImSet<T> col); static void openFile(RawFileData data, String name, String extension); static String getFileName(String name, String extension); static String firstWord(String string, String separator); static String encode(int... values); static Integer[] decode(int number, String string); @SuppressWarnings({"UnusedDeclaration"}) static String formatRussian(Date date); static String formatRussian(Date date, TimeZone timeZone); static String formatRussian(Date date, TimeZone timeZone, boolean noYear); static String formatRussian(Date date, boolean quotes, boolean leadZero); static String formatRussian(Date date, boolean quotes, boolean leadZero, boolean noYear); static String formatRussian(Date date, boolean quotes, boolean leadZero, TimeZone timeZone); static String formatRussian(Date date, boolean quotes, boolean leadZero, TimeZone timeZone, boolean noYear); @SuppressWarnings({"UnusedDeclaration"}) static String formatRussian(LocalDate date); static String formatRussian(LocalDate date, boolean noYear); static String formatRussian(LocalDate date, boolean quotes, boolean leadZero); static String formatRussian(LocalDate date, boolean quotes, boolean leadZero, boolean noYear); @SuppressWarnings({"UnusedDeclaration"}) static String formatEnglish(Date date); static String formatEnglish(Date date, boolean quotes, boolean leadZero); static String formatEnglish(Date date, boolean quotes, boolean leadZero, TimeZone timeZone); @SuppressWarnings({"UnusedDeclaration"}) static String formatEnglish(LocalDate date); static String formatEnglish(LocalDate date, boolean quotes, boolean leadZero); static String justInitials(String fullName, boolean lastNameFirst, boolean revert); static String intToFeminine(int number); static Date getFirstDateInMonth(int year, int month); static Date getLastDateInMonth(int year, int month); static String getFileExtension(File file); static String getFileExtension(String filename); static Object filesToBytes(boolean multiple, boolean storeName, boolean custom, File... files); static int[] consecutiveInts(int length); static int[] toPrimitive(List<Integer> array); static int max(int a, int b); static double max(double a, double b); static int cmp(int a, int b, boolean max); static boolean cmp(boolean a, boolean b, boolean max); static SimpleAddValue<K, Integer> addMinInt(); static int min(int a, int b); static long max(long a, long b); static long min(long a, long b); static double min(double a, double b); static List<Integer> consecutiveList(int length, int start); static List<Integer> consecutiveList(int i); static List<K> sort(Collection<K> col, Comparator<K> comparator); static FunctionSet<K> merge(FunctionSet<K>... sets); static FunctionSet<K> merge(FunctionSet<K> set1, FunctionSet<K> set2); static FunctionSet<K> mergeElement(FunctionSet<K> set1, K element); static FunctionSet<K> remove(FunctionSet<K> set1, FunctionSet<K> set2); static boolean containsAll(FunctionSet<K> set1, ImSet<K> set2); static FunctionSet<T> universal(boolean empty); static void putUpdate(Map<MK, Map<K, V>> keyValues, MK key, Map<K, V> values, boolean update); static M getNearObject(V findValue, List<M> keys); static V getNearValue(K findKey, V findValue, List<M> keys); static String randomString(int len); static String calculateBase64Hash(String algorithm, String input, Object salt); static byte[] calculateHash(String algorithm, String input, Object salt); static String calculateBase64HashOld(String algorithm, String input, Object salt); static String calculateHashOld(String algorithm, String input, Object salt); static int compareInts(int a, int b); static void runLater(final int delay, final Runnable runnable); static void addToOrderedList(List<T> orderedList, T element, int after, Comparator<T> compare); static String bigDecimalToString(BigDecimal bd); static String bigDecimalToString(String format, BigDecimal bd); static String dateToString(Date d); static String dateToString(String format, Date d); static String dateToString(LocalDate d); static String dateToString(String format, LocalDate d); static String packWords(String string, int reqLength); static Iterable<T> mergeIterables(final Iterable<T> it1, final Iterable<T> it2); static Iterator<T> mergeIterators(final Iterator<T> it1, final Iterator<T> it2); static Iterable<T> sort(Iterable<T> it, Comparator<T> comparator); static ImSet<V> getAllChildren(V vthis, ChildrenInterface<V> cint); static void fillChildren(V vthis, ChildrenInterface<V> cint, MSet<V> classSet); static ImSet<V> commonChildren(V vthis, V toCommon, ExChildrenInterface<V> cint); static void fillDiffChildren(V vthis, ExChildrenInterface<V> cint, V vdiff, MSet<V> mAdd, MSet<V> mRemove); static double pow(double value, int pow); static double pow(double value, long pow); static String trimToEmpty(String str); static String trim(String str); static boolean isEmpty(String str); static String trimToNull(String str); static String substring(String value, int length); static int indexOf(PriorityQueue<E> queue, E element); static String defaultToString(Object o); static String removeTrailingSlash(String s); static List<String> split(String s, String f); static String generatePassword(int length, boolean useAtLeastOneDigit, boolean useBothRegisters); static Object executeWithTimeout(Callable<Object> callable, Integer timeout); }
BaseUtils { public static String dateToString(Date d) { return dateToString("dd/MM/yyyy", d); }  static Integer getApiVersion(); static String getPlatformVersion(); static String checkClientVersion(String serverPlatformVersion, Integer serverApiVersion, String clientPlatformVersion, Integer clientApiVersion); static boolean nullEquals(Object obj1, Object obj2); static int nullCompareTo(Comparable obj1, Comparable obj2); static boolean nullHashEquals(Object obj1, Object obj2); static int nullHash(Object obj); static boolean findByReference(Collection<T> col, Object obj); static boolean[] convertArray(Boolean[] array); static boolean mapEquals(Map<KA, VA> mapA, Map<KB, VB> mapB, Map<KA, KB> mapAB); static Map<K, V> nullJoin(Map<K, ? extends E> map, Map<E, V> joinMap); static Map<K, V> join(Map<K, ? extends E> map, Map<E, V> joinMap); static Map<K, E> joinKeep(Map<K, ? extends E> map, Map<E, E> joinMap); static Map<K, V> rightJoin(Map<K, E> map, Map<R, V> joinMap); static Map<VA, VB> rightCrossJoin(Map<K, VA> map, Map<K, VB> joinMap); static Map<VA, VB> rightNullCrossJoin(Map<K, VA> map, Map<K, VB> joinMap); static List<Map<K, V>> joinCol(Map<K, ? extends E> map, Collection<Map<E, V>> list); static List<V> mapList(List<? extends K> list, ImMap<K, ? extends V> map); static List<K> mapList(Integer[] mapList, List<K> list); static OrderedMap<K, V> mapOrder(List<? extends K> list, Map<K, ? extends V> map); static OrderedMap<V, E> mapOrder(OrderedMap<K, E> list, Map<K, ? extends V> map); static Set<V> mapSet(Set<K> set, Map<K, ? extends V> map); static Map<K, V> innerJoin(Map<K, ? extends E> map, Map<? extends E, V> joinMap); static Map<K, V> nullInnerJoin(Map<K, ? extends E> map, Map<? extends E, V> joinMap); static OrderedMap<K, V> innerJoin(OrderedMap<K, E> map, Map<E, V> joinMap); static Map<K, F> filterValues(Map<K, V> map, Collection<F> values); static Collection<K> filterValues(Map<K, V> map, V value); static Map<K, V> filterInclKeys(Map<BK, V> map, Set<? extends K> keys); static Map<K, V> filterKeys(Map<BK, V> map, Iterable<? extends K> keys); static Map<K, V> filterKeys(Map<BK, V> map, FunctionSet<K> filter, Class<K> aClass); static Map<K, V> filterKeys(Iterable<BK> keys, Map<K, V> map); static Map<K, V> filterInclKeys(Map<BK, V> map, Iterable<? extends K> keys); static Iterable<E> filterIterable(final Iterable<E> iterable, final FunctionSet<E> filter); static Map<K, CV> filterClass(Map<K, V> map, Class<CV> cvClass); static Map<K, V> filterNotKeys(Map<K, V> map, Collection<? extends K> keys); static Map<K, V> filterNotKeys(Map<K, V> map, FunctionSet<T> keys, Class<T> aClass); static Map<K, V> filterNotValues(Map<K, V> map, Collection<? extends V> values); static Collection<K> filter(Collection<K> col, Collection<BK> filter); static List<K> filterList(List<K> list, ImSet<K> filter); static List<K> filterList(List<K> list, Collection<K> filter); static List<K> filterNotList(List<K> list, Collection<K> filter); static Set<K> filterSet(Set<K> set, Collection<K> filter); static Set<K> filterNotSet(Set<K> set, Collection<K> filter); static Collection<K> filterNot(Collection<K> col, Collection<BK> filter); static Map<K, V> splitKeys(Map<BK, V> map, HSet<K> keys, Map<BK, V> rest); static Map<K, V> splitValues(Map<K, BV> map, Collection<V> keys, Map<K, BV> rest); static Map<K, V> mergeEquals(Map<K, V> full, Map<K, V> part); static Map<V, K> reverse(Map<K, V> map); static Map<V, K> reverse(Map<K, V> map, boolean ignoreUnique); static Map<VA, VB> crossJoin(Map<K, VA> map, Map<K, VB> mapTo); static Map<VA, VB> crossJoin(Map<KA, VA> map, Map<KB, VB> mapTo, Map<KA, KB> mapJoin); static Map<KA, KB> crossValues(Map<KA, V> map, Map<KB, V> mapTo); static Map<KA, KB> rightCrossValues(Map<KA, V> map, Map<KB, V> mapTo); static Map<KA, KB> crossInnerValues(Map<KA, V> map, Map<KB, V> mapTo); static Map<KA, KB> crossValues(Map<KA, V> map, Map<KB, V> mapTo, boolean ignoreUnique); static Map<T, VA> splitInnerJoin(Map<T, K> mapTo, Map<K, VA> map1, Map<K, VB> map2, Map<T, VB> res2); static Collection<K> join(Collection<K> col1, Collection<K> col2); static boolean identity(Map<K, V> map); static Map<K, K> toMap(Set<K> collection); static Map<K, K> toMap(Collection<K> collection); static Map<K, V> toMap(List<K> from, List<V> to); static Map<Object, K> toObjectMap(Set<K> collection); static Map<K, V> toMap(Collection<K> collection, V value); static Map<Integer, K> toMap(List<K> list); static OrderedMap<K, V> toOrderedMap(List<? extends K> list, V value); static Map<Integer, K> toMap(K[] list); static List<K> toList(Map<Integer, K> map); static Object deserializeObject(byte[] state); static Object deserializeObject(DataInputStream inStream); static String deserializeString(DataInputStream inStream); static byte[] serializeObject(Object value); static void serializeObject(DataOutputStream outStream, Object object); static byte[] serializeCustomObject(Object object); static Object deserializeCustomObject(byte[] bytes); static void serializeString(DataOutputStream outStream, String str); static void serializeBigDecimal(DataOutputStream outStream, BigDecimal number); static BigDecimal deserializeBigDecimal(DataInputStream inStream); static boolean startsWith(char[] string, int off, char[] check); static Map<K, V> removeKeys(Map<K, V> map, Collection<K> remove); static Map<K, V> removeKey(Map<K, V> map, K remove); static Collection<K> add(Collection<? extends K> col, K add); static Set<K> addSet(Set<? extends K> col, K add); static List<K> add(List<K> col, K add); static Map<K, V> add(Map<? extends K, ? extends V> map, K add, V addValue); static List<K> add(K add, List<? extends K> col); static Collection<K> remove(Collection<? extends K> set, Collection<? extends K> remove); static Collection<K> remove(Collection<? extends K> set, K remove); static List<K> remove(List<? extends K> set, int remove); static Set<K> removeSet(Set<? extends K> set, Collection<? extends K> remove); static List<K> removeList(List<K> list, Collection<K> remove); static List<K> removeList(List<K> list, K remove); static List<K> removeList(List<K> list, int index); static K lastSetElement(Set<K> set); static void moveElement(List<K> list, K elemFrom, K elemTo); static void moveElement(List<K> list, K elemFrom, int index); static LinkedHashMap<B, V> mergeLinked(LinkedHashMap<K1, ? extends V> map1, LinkedHashMap<K2, ? extends V> map2); static Map<B, V> merge(Map<K1, ? extends V> map1, Map<K2, ? extends V> map2); static Map<B, V> override(Map<K1, ? extends V> map1, Map<K2, ? extends V> map2); static Map<K1, V> replace(Map<K1, ? extends V> map1, Map<K2, ? extends V> map2); static Map<K1, V> replaceValues(Map<K1, ? extends V> map1, Map<? extends V, ? extends V> map2); static Map<K, V> replace(Map<K, ? extends V> map, K key, V value); static boolean isSubMap(Map<? extends K, ? extends V> map1, Map<K, ? extends V> map2); static Collection<B> merge(Collection<K1> col1, Collection<K2> col2); static Set<B> mergeSet(Set<K1> set1, Set<K2> set2); static Set<B> mergeColSet(Collection<K1> set1, Collection<K2> set2); static Set<B> mergeItem(Set<K1> set, K2 item); static List<B> addList(B item, List<? extends B> list); static List<B> mergeList(List<? extends B> list1, List<? extends B> list2); @SafeVarargs static List<B> mergeLists(List<B>... lists); static Map<Object, EV> mergeMaps(Map<V, EV> map, Map<MV, EV> toMerge, Map<MV, Object> mergedMap); static List<List<T>> cartesianProduct(List<List<T>> data); static K findDeadEnd(Map<K, K> map, K end); static boolean equalArraySets(T[] array1, T[] array2); static int hashSet(T[] array); static T nvl(T value1, T value2); static BigDecimal nvl(BigDecimal value1, Double value2); static String evl(String primary, String secondary); static String nevl(String primary, String secondary); static boolean hashEquals(Object obj1, Object obj2); static boolean contains(T[] array, T element); static boolean contains(T[] array, T element, int num); static Set<T> toSet(T... array); static T getRandom(List<T> list, Random randomizer); static String clause(String clause, String data); static OrderedMap<T, K> orderMap(Map<T, K> map, Iterable<T> list); static List<T> orderList(Set<T> map, Iterable<BT> list); static OrderedMap<K, V> mergeOrders(OrderedMap<K, V> map1, OrderedMap<K, V> map2); static Map<V, V> mergeMaps(Map<V, V>[] maps); static void replaceListElements(List<T> list, T from, T to); static boolean replaceListElements(List<T> list, ImMap<T, T> to); static Long nullToZero(Long value); static Object nullZero(String str); static Object nullString(String str); static String nullToString(Object str); static Object nullBoolean(Boolean b); static Integer nullParseInt(String s); static Integer parseInt(String value); static String replaceSeparators(String value, char separator, char groupingSeparator); static String replaceCommaSeparator(String value); static String replaceDotSeparator(String value); static void clearNotKeys(Map<K, V> map, FunctionSet<T> keep, Class<T> aClass); static double nullAdd(Double p1, Double p2); static Map<G, Collection<K>> group(Group<G, K> getter, Iterable<K> keys); static Map<G, List<K>> groupList(Group<G, K> getter, List<K> keys); static Map<G, Set<K>> groupSet(Group<G, K> getter, Collection<K> keys); static Map<G, Set<K>> groupSet(final Map<K, G> getter, Set<K> keys); static Map<G, List<K>> groupList(final Map<K, G> getter, List<K> keys); static Map<G, Set<K>> groupSet(final Map<K, G> getter); static Map<G, Set<K>> groupSet(final HMap<K, G> getter, Collection<K> keys); static Map<G, List<K>> groupList(final OrderedMap<K, G> getter); static SortedMap<G, Set<K>> groupSortedSet(Group<G, K> getter, Collection<K> keys, Comparator<? super G> comparator); static SortedMap<G, Set<K>> groupSortedSet(final Map<K, G> getter, Comparator<? super G> comparator); static SortedMap<G, Set<K>> groupSortedSet(final Map<K, G> getter); static Map<K, Integer> multiSet(Collection<K> col); static V addValue(Map<V, V> values, V value); static void putNotNull(K key, Map<K, V> from, Map<K, V> to); static boolean hashContainsValue(Map<K, V> map, V value); static String toString(Collection<K> array, String separator); static String toString(String separator, K... array); static boolean containsAll(Map<K, V> map, Map<K, V> contains); static Map<K, String> mapString(Collection<K> col); static Integer[] toObjectArray(int[] a); static Integer[] toOneBasedArray(int[] a); static Object[] add(Object element, Object[] array1); static Object[] add(Object[] array1, Object element); static Object[] add(Object[] array1, Object[] array2); static Object[] add(List<Object[]> list); static T[] add(T[] array1, T[] array2, ArrayInstancer<T> instancer); static T[] add(List<T> list1, T[] array2, ArrayInstancer<T> instancer); static T[] addElement(T[] array, T element, Class<T> elementClass); static T[] addElement(T element, T[] array, Class<T> elementClass); static T[] addElement(T[] array, T element, ArrayInstancer<T> instancer); static T[] addElement(T element, T[] array, ArrayInstancer<T> instancer); static int[] addInt(int[] array, int element); static T[] removeElement(T[] array, T element, ArrayInstancer<T> instancer); static T[] genArray(T element, int length, ArrayInstancer<T> instancer); static String[] genArray(String element, int length); static int[] genArray(int element, int length); static List<E> immutableCast(List<I> list); static Map<K, E> immutableCast(Map<K, I> map); static I immutableCast(Object object); static String tab(String tab); static String tabPrefix(String tab, String prefix); static I single(Collection<I> col); static I single(Iterable<I> col); static I single(I[] array); static I singleKey(Map<I, ?> map); static I singleValue(Map<?, I> map); static Map.Entry<K, I> singleEntry(Map<K, I> map); static List<K> reverse(List<K> col); static List<K> toList(Iterable<K> col); static List<K> reverse(Iterable<K> col); static List<K> reverseThis(List<K> col); static int objectToInt(Integer value); static Integer intToObject(int value); static String nullTrim(String string); static String nullEmpty(String string); static String rtrim(String string); static String toCaption(Object name); static Map<K, V> buildMap(Collection<K> col1, Collection<V> col2); @SafeVarargs static List<K> toList(K... elements); static List<K> toListNoNull(K... elements); static String replicate(char character, int length); static String truncate(String s, int length); static String padRight(String s, int n); static String padLeft(String s, int n); static String capitalize(String s); static boolean isRedundantString(String s); static boolean isRedundantString(Object o); static String spaces(int count); static String padr(String string, int length); static String padl(String string, int length); static String padl(String string, int length, char character); static int countRepeatingChars(String string, char character, int index); static K last(List<K> list); static int relativePosition(K element, List<K> comparatorList, List<K> insertList); static int[] relativeIndexes(List<T> all, List<T> list); static List<K> copyTreeChildren(List children); static HashComponents<K> getComponents(HashInterface<K, C> hashInterface); static boolean onlyObjects(Iterable<?> col); static ImRevMap<T, Object> generateObjects(ImSet<T> col); static void openFile(RawFileData data, String name, String extension); static String getFileName(String name, String extension); static String firstWord(String string, String separator); static String encode(int... values); static Integer[] decode(int number, String string); @SuppressWarnings({"UnusedDeclaration"}) static String formatRussian(Date date); static String formatRussian(Date date, TimeZone timeZone); static String formatRussian(Date date, TimeZone timeZone, boolean noYear); static String formatRussian(Date date, boolean quotes, boolean leadZero); static String formatRussian(Date date, boolean quotes, boolean leadZero, boolean noYear); static String formatRussian(Date date, boolean quotes, boolean leadZero, TimeZone timeZone); static String formatRussian(Date date, boolean quotes, boolean leadZero, TimeZone timeZone, boolean noYear); @SuppressWarnings({"UnusedDeclaration"}) static String formatRussian(LocalDate date); static String formatRussian(LocalDate date, boolean noYear); static String formatRussian(LocalDate date, boolean quotes, boolean leadZero); static String formatRussian(LocalDate date, boolean quotes, boolean leadZero, boolean noYear); @SuppressWarnings({"UnusedDeclaration"}) static String formatEnglish(Date date); static String formatEnglish(Date date, boolean quotes, boolean leadZero); static String formatEnglish(Date date, boolean quotes, boolean leadZero, TimeZone timeZone); @SuppressWarnings({"UnusedDeclaration"}) static String formatEnglish(LocalDate date); static String formatEnglish(LocalDate date, boolean quotes, boolean leadZero); static String justInitials(String fullName, boolean lastNameFirst, boolean revert); static String intToFeminine(int number); static Date getFirstDateInMonth(int year, int month); static Date getLastDateInMonth(int year, int month); static String getFileExtension(File file); static String getFileExtension(String filename); static Object filesToBytes(boolean multiple, boolean storeName, boolean custom, File... files); static int[] consecutiveInts(int length); static int[] toPrimitive(List<Integer> array); static int max(int a, int b); static double max(double a, double b); static int cmp(int a, int b, boolean max); static boolean cmp(boolean a, boolean b, boolean max); static SimpleAddValue<K, Integer> addMinInt(); static int min(int a, int b); static long max(long a, long b); static long min(long a, long b); static double min(double a, double b); static List<Integer> consecutiveList(int length, int start); static List<Integer> consecutiveList(int i); static List<K> sort(Collection<K> col, Comparator<K> comparator); static FunctionSet<K> merge(FunctionSet<K>... sets); static FunctionSet<K> merge(FunctionSet<K> set1, FunctionSet<K> set2); static FunctionSet<K> mergeElement(FunctionSet<K> set1, K element); static FunctionSet<K> remove(FunctionSet<K> set1, FunctionSet<K> set2); static boolean containsAll(FunctionSet<K> set1, ImSet<K> set2); static FunctionSet<T> universal(boolean empty); static void putUpdate(Map<MK, Map<K, V>> keyValues, MK key, Map<K, V> values, boolean update); static M getNearObject(V findValue, List<M> keys); static V getNearValue(K findKey, V findValue, List<M> keys); static String randomString(int len); static String calculateBase64Hash(String algorithm, String input, Object salt); static byte[] calculateHash(String algorithm, String input, Object salt); static String calculateBase64HashOld(String algorithm, String input, Object salt); static String calculateHashOld(String algorithm, String input, Object salt); static int compareInts(int a, int b); static void runLater(final int delay, final Runnable runnable); static void addToOrderedList(List<T> orderedList, T element, int after, Comparator<T> compare); static String bigDecimalToString(BigDecimal bd); static String bigDecimalToString(String format, BigDecimal bd); static String dateToString(Date d); static String dateToString(String format, Date d); static String dateToString(LocalDate d); static String dateToString(String format, LocalDate d); static String packWords(String string, int reqLength); static Iterable<T> mergeIterables(final Iterable<T> it1, final Iterable<T> it2); static Iterator<T> mergeIterators(final Iterator<T> it1, final Iterator<T> it2); static Iterable<T> sort(Iterable<T> it, Comparator<T> comparator); static ImSet<V> getAllChildren(V vthis, ChildrenInterface<V> cint); static void fillChildren(V vthis, ChildrenInterface<V> cint, MSet<V> classSet); static ImSet<V> commonChildren(V vthis, V toCommon, ExChildrenInterface<V> cint); static void fillDiffChildren(V vthis, ExChildrenInterface<V> cint, V vdiff, MSet<V> mAdd, MSet<V> mRemove); static double pow(double value, int pow); static double pow(double value, long pow); static String trimToEmpty(String str); static String trim(String str); static boolean isEmpty(String str); static String trimToNull(String str); static String substring(String value, int length); static int indexOf(PriorityQueue<E> queue, E element); static String defaultToString(Object o); static String removeTrailingSlash(String s); static List<String> split(String s, String f); static String generatePassword(int length, boolean useAtLeastOneDigit, boolean useBothRegisters); static Object executeWithTimeout(Callable<Object> callable, Integer timeout); static final Logger systemLogger; static final Logger serviceLogger; static final String lineSeparator; final static ArrayInstancer<Object> objectInstancer; final static ArrayInstancer<String> stringInstancer; static String[] monthsRussian; static String[] monthsEnglish; static String[] feminineNumbers; static final String impossibleString; }