All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.nd4j.common.io.CollectionUtils Maven / Gradle / Ivy
/*
* ******************************************************************************
* *
* *
* * This program and the accompanying materials are made available under the
* * terms of the Apache License, Version 2.0 which is available at
* * https://www.apache.org/licenses/LICENSE-2.0.
* *
* * See the NOTICE file distributed with this work for additional
* * information regarding copyright ownership.
* * Unless required by applicable law or agreed to in writing, software
* * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* * License for the specific language governing permissions and limitations
* * under the License.
* *
* * SPDX-License-Identifier: Apache-2.0
* *****************************************************************************
*/
package org.nd4j.common.io;
import org.nd4j.common.util.MultiValueMap;
import java.io.Serializable;
import java.util.*;
import java.util.Map.Entry;
public abstract class CollectionUtils {
public CollectionUtils() {}
public static boolean isEmpty(Collection collection) {
return collection == null || collection.isEmpty();
}
public static boolean isEmpty(Map map) {
return map == null || map.isEmpty();
}
public static List arrayToList(Object source) {
return Arrays.asList(ObjectUtils.toObjectArray(source));
}
public static void mergeArrayIntoCollection(Object array, Collection collection) {
if (collection == null) {
throw new IllegalArgumentException("Collection must not be null");
} else {
Object[] arr = ObjectUtils.toObjectArray(array);
Object[] arr$ = arr;
int len$ = arr.length;
for (int i$ = 0; i$ < len$; ++i$) {
Object elem = arr$[i$];
collection.add(elem);
}
}
}
public static void mergePropertiesIntoMap(Properties props, Map map) {
if (map == null) {
throw new IllegalArgumentException("Map must not be null");
} else {
String key;
Object value;
if (props != null) {
for (Enumeration en = props.propertyNames(); en.hasMoreElements(); map.put(key, value)) {
key = (String) en.nextElement();
value = props.getProperty(key);
if (value == null) {
value = props.get(key);
}
}
}
}
}
public static boolean contains(Iterator iterator, Object element) {
if (iterator != null) {
while (iterator.hasNext()) {
Object candidate = iterator.next();
if (ObjectUtils.nullSafeEquals(candidate, element)) {
return true;
}
}
}
return false;
}
public static boolean contains(Enumeration enumeration, Object element) {
if (enumeration != null) {
while (enumeration.hasMoreElements()) {
Object candidate = enumeration.nextElement();
if (ObjectUtils.nullSafeEquals(candidate, element)) {
return true;
}
}
}
return false;
}
public static boolean containsInstance(Collection collection, Object element) {
if (collection != null) {
Iterator i$ = collection.iterator();
while (i$.hasNext()) {
Object candidate = i$.next();
if (candidate == element) {
return true;
}
}
}
return false;
}
public static boolean containsAny(Collection source, Collection candidates) {
if (!isEmpty(source) && !isEmpty(candidates)) {
Iterator i$ = candidates.iterator();
Object candidate;
do {
if (!i$.hasNext()) {
return false;
}
candidate = i$.next();
} while (!source.contains(candidate));
return true;
} else {
return false;
}
}
public static Object findFirstMatch(Collection source, Collection candidates) {
if (!isEmpty(source) && !isEmpty(candidates)) {
Iterator i$ = candidates.iterator();
Object candidate;
do {
if (!i$.hasNext()) {
return null;
}
candidate = i$.next();
} while (!source.contains(candidate));
return candidate;
} else {
return null;
}
}
public static T findValueOfType(Collection collection, Class type) {
if (isEmpty((Collection) collection)) {
return null;
} else {
Object value = null;
Iterator i$ = collection.iterator();
while (i$.hasNext()) {
Object element = i$.next();
if (type == null || type.isInstance(element)) {
if (value != null) {
return null;
}
value = element;
}
}
return (T) value;
}
}
public static Object findValueOfType(Collection collection, Class[] types) {
if (!isEmpty((Collection) collection) && !ObjectUtils.isEmpty(types)) {
Class[] arr$ = types;
int len$ = types.length;
for (int i$ = 0; i$ < len$; ++i$) {
Class type = arr$[i$];
Object value = findValueOfType(collection, type);
if (value != null) {
return value;
}
}
return null;
} else {
return null;
}
}
public static boolean hasUniqueObject(Collection collection) {
if (isEmpty(collection)) {
return false;
} else {
boolean hasCandidate = false;
Object candidate = null;
Iterator i$ = collection.iterator();
while (i$.hasNext()) {
Object elem = i$.next();
if (!hasCandidate) {
hasCandidate = true;
candidate = elem;
} else if (candidate != elem) {
return false;
}
}
return true;
}
}
public static Class findCommonElementType(Collection collection) {
if (isEmpty(collection)) {
return null;
} else {
Class candidate = null;
Iterator i$ = collection.iterator();
while (i$.hasNext()) {
Object val = i$.next();
if (val != null) {
if (candidate == null) {
candidate = val.getClass();
} else if (candidate != val.getClass()) {
return null;
}
}
}
return candidate;
}
}
public static A[] toArray(Enumeration enumeration, A[] array) {
ArrayList elements = new ArrayList();
while (enumeration.hasMoreElements()) {
elements.add(enumeration.nextElement());
}
return (A[]) elements.toArray(array);
}
public static Iterator toIterator(Enumeration enumeration) {
return new CollectionUtils.EnumerationIterator(enumeration);
}
public static MultiValueMap toMultiValueMap(Map> map) {
return new CollectionUtils.MultiValueMapAdapter(map);
}
public static MultiValueMap unmodifiableMultiValueMap(MultiValueMap map) {
Assert.notNull(map, "\'map\' must not be null");
LinkedHashMap result = new LinkedHashMap(map.size());
Iterator unmodifiableMap = map.entrySet().iterator();
while (unmodifiableMap.hasNext()) {
Entry entry = (Entry) unmodifiableMap.next();
List values = Collections.unmodifiableList((List) entry.getValue());
result.put(entry.getKey(), values);
}
Map unmodifiableMap1 = Collections.unmodifiableMap(result);
return toMultiValueMap(unmodifiableMap1);
}
private static class MultiValueMapAdapter implements MultiValueMap, Serializable {
private final Map> map;
public MultiValueMapAdapter(Map> map) {
Assert.notNull(map, "\'map\' must not be null");
this.map = map;
}
public void add(K key, V value) {
List values = this.map.get(key);
if (values == null) {
values = new LinkedList<>();
this.map.put(key, values);
}
values.add(value);
}
public V getFirst(K key) {
List values = this.map.get(key);
return values != null ? (V) values.get(0) : null;
}
public void set(K key, V value) {
LinkedList values = new LinkedList();
values.add(value);
this.map.put(key, values);
}
public void setAll(Map values) {
Iterator i$ = values.entrySet().iterator();
while (i$.hasNext()) {
Entry entry = (Entry) i$.next();
this.set((K) entry.getKey(), (V) entry.getValue());
}
}
public Map toSingleValueMap() {
LinkedHashMap singleValueMap = new LinkedHashMap(this.map.size());
Iterator i$ = this.map.entrySet().iterator();
while (i$.hasNext()) {
Entry entry = (Entry) i$.next();
singleValueMap.put(entry.getKey(), ((List) entry.getValue()).get(0));
}
return singleValueMap;
}
public int size() {
return this.map.size();
}
public boolean isEmpty() {
return this.map.isEmpty();
}
public boolean containsKey(Object key) {
return this.map.containsKey(key);
}
public boolean containsValue(Object value) {
return this.map.containsValue(value);
}
public List get(Object key) {
return this.map.get(key);
}
public List put(K key, List value) {
return this.map.put(key, value);
}
public List remove(Object key) {
return this.map.remove(key);
}
public void putAll(Map> m) {
this.map.putAll(m);
}
public void clear() {
this.map.clear();
}
public Set keySet() {
return this.map.keySet();
}
public Collection> values() {
return this.map.values();
}
public Set>> entrySet() {
return this.map.entrySet();
}
public boolean equals(Object other) {
return this == other ? true : this.map.equals(other);
}
public int hashCode() {
return this.map.hashCode();
}
public String toString() {
return this.map.toString();
}
}
private static class EnumerationIterator implements Iterator {
private Enumeration enumeration;
public EnumerationIterator(Enumeration enumeration) {
this.enumeration = enumeration;
}
public boolean hasNext() {
return this.enumeration.hasMoreElements();
}
public E next() {
return this.enumeration.nextElement();
}
public void remove() throws UnsupportedOperationException {
throw new UnsupportedOperationException("Not supported");
}
}
}
