public static <R, I, C extends Collection<R>> C collect(
Iterable<? extends I> source, C destination, Transformer<R, I> transformer) {
for (I item : source) {
destination.add(transformer.transform(item));
}
return destination;
}
/** @return the sum of the values of all the counters. */
public final C sum() {
final C sum = factory.newInstance();
for (C c : counts.values()) {
sum.add(c);
}
return sum;
}
/**
* 根据指定集合生成树<br>
* 首先找到不存在父节点的所有节点，将这些节点当作根节点<br>
* 然后利用这些根节点迭代生成树<br>
* 允许通过参数限制生成树的层数 <功能详细描述>
*
* @param treeAbleCollection
* @param maxLevelIndex
* @return [参数说明]
* @return C [返回类型说明]
* @exception throws [异常类型] [异常说明]
* @see [类、类#方法、类#成员]
*/
@SuppressWarnings("rawtypes")
public static <C extends Collection<T>, T extends TreeAble> C changToTree(
C treeAbleCollection, int maxLevelIndex) {
// 判断入参是否合法
if (treeAbleCollection == null || treeAbleCollection.size() == 0) {
// 如果root或需要转换的集合其中有一个为空，直接返回root集合当作结果
return treeAbleCollection;
}
C parentNodeCollection = newCollectionInstance(treeAbleCollection);
// 循环得到当前传入list上级节点有多少个
// 并进行非法节点过滤，如果某节点id = parentId将会造成死循环 ,将这样的节点抛弃
Map<String, C> parentIdIndexMap = new HashMap<String, C>();
Set<String> treeAbleNodeIdSet = new HashSet<String>();
for (T treeAbleTemp : treeAbleCollection) {
String superId = treeAbleTemp.getParentId();
String id = treeAbleTemp.getId();
treeAbleNodeIdSet.add(treeAbleTemp.getId());
if (StringUtils.isEmpty(id) || id.equals(superId)) {
// 并进行非法节点过滤，如果某节点id = parentId将会造成死循环
// 非法节点在该方法中将被当作根节点放置于树中
// doNothing
parentNodeCollection.add(treeAbleTemp);
continue;
}
// 根据父节点形成父ID与集合的映射
if (parentIdIndexMap.containsKey(superId)) {
parentIdIndexMap.get(superId).add(treeAbleTemp);
} else {
C collectionTemp = newCollectionInstance(treeAbleCollection);
collectionTemp.add(treeAbleTemp);
parentIdIndexMap.put(superId, collectionTemp);
}
}
// 迭代生成根节点集合
for (T treeAbleTemp : treeAbleCollection) {
if (!treeAbleNodeIdSet.contains(treeAbleTemp.getParentId())) {
parentNodeCollection.add(treeAbleTemp);
}
}
return changeToTreeByParentIdIndexMap(parentNodeCollection, maxLevelIndex, parentIdIndexMap);
}
public static <K, V, C extends Collection<K>> C toCollection(
final C target, final V[] collection, final ITranslator<V, K> translator) {
for (final V value : collection) {
target.add(translator.translate(value));
}
return target;
}
public static <T, C extends Collection<T>> C addAll(
C collection, Iterable<? extends T> iterable) {
for (T item : iterable) {
collection.add(item);
}
return collection;
}
@NotNull
private static <T, C extends Collection<T>> C copy(
@NotNull C collection, @NotNull Iterable<? extends T> elements) {
for (T element : elements) {
collection.add(element);
}
return collection;
}
/**
* Adds the value to the collection given by map.get(key). A new collection is created using the
* supplied CollectionFactory.
*/
public static <K, V, C extends Collection<V>> void putIntoValueCollection(
Map<K, C> map, K key, V value, CollectionFactory<V> cf) {
C c = map.get(key);
if (c == null) {
c = ErasureUtils.<C>uncheckedCast(cf.newCollection());
map.put(key, c);
}
c.add(value);
}
private C collectionFromWire() {
C c = factory.get();
@SuppressWarnings("ConstantConditions")
final ValueIn valueIn = ((Wire) outWire).getValueIn();
while (valueIn.hasNextSequenceItem()) {
c.add(fromWire.apply(valueIn));
}
return c;
}
public static <T, C extends Collection<T>> C filter(
Iterable<? extends T> source, C destination, Spec<? super T> filter) {
for (T item : source) {
if (filter.isSatisfiedBy(item)) {
destination.add(item);
}
}
return destination;
}
/**
* Removes at most n elements from the given iterable, and adds it to the output collection
*
* @param <T>
* @param <C>
* @param iterable
* @param amountOfElements the max amount of elements to select from the iterable. Must be >= 0
* @param collection
* @return the output collection
*/
@NonNull
public static <T, C extends Collection<T>> C move(
@NonNull Iterable<T> iterable, @NotNegative int amountOfElements, @NonNull C collection) {
Iterator<? extends T> iter = iterable.iterator();
for (int i = 0; i < amountOfElements && iter.hasNext(); i++) {
collection.add(iter.next());
iter.remove();
}
return collection;
}
private <C extends Collection<URI>> C addConcept(Resource resource, Class<?> role, C set)
throws RepositoryException {
URI type = of.getNameOf(role);
if (type == null) {
throw new ObjectPersistException(
"Concept is anonymous or is not registered: " + role.getSimpleName());
}
types.addTypeStatement(resource, type);
set.add(type);
return set;
}
/**
* Removes all elements from the given iterable that evalute to true, and adds them to the given
* collection
*
* @param iterable
* @param collection
* @param predicate
* @param <T>
* @param <C>
* @return the given collection
*/
@NonNull
public static <T, C extends Collection<T>> C move(
@NonNull Iterable<T> iterable, @NonNull C collection, @NonNull Evaluable<T> predicate) {
for (Iterator<T> iter = iterable.iterator(); iter.hasNext(); ) {
T element = iter.next();
if (predicate.eval(element)) {
iter.remove();
collection.add(element);
}
}
return collection;
}
private <C extends Collection<E>, E> C _convertContents(
Collection collection, Class<C> collectionClass, Class<E> elementClass) {
C coll = (C) CollectionUtils.instanceOf(collectionClass);
for (Object obj : collection) {
try {
E e = convert(obj, elementClass);
coll.add(e);
} catch (ConversionException ex) {
}
}
setCachedElementType(coll, elementClass);
return coll;
}
/** Given a map that maps to collections, adds a new key/value pair or introduces the key */
@SuppressWarnings("unchecked")
public static <K, V, C extends Collection<V>, L extends Collection> void addKeyValue(
Map<K, C> map, K key, V value, Class<L> collectionType) {
C coll = map.get(key);
if (coll == null) {
try {
map.put(key, coll = (C) collectionType.newInstance());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
coll.add(value);
}
private <C extends Collection<R>> C mapInto(C collection, ResultSet rs) throws SQLException {
R root = null;
I previousId = null;
while (rs.next()) {
I id = mapId(rs);
if (!id.equals(previousId)) {
root = mapRoot(id, rs);
collection.add(root);
}
addChild(root, rs);
previousId = id;
}
return collection;
}
@Override
protected C readValue(Command resp) throws TraCIException {
Storage content = resp.content();
List<String> ids = new StringList(content, true);
C out = makeCollection();
for (String id : ids) {
try {
out.add(repository.getByID(id));
} catch (IOException e) {
throw new TraCIException(e.toString());
}
}
return out;
}
@Override
public <E, C extends Collection<? super E>> C readCollection(
String fieldName, C collection, Class<E> elementClass) throws IOException {
final FieldDescriptor fd = messageContext.marshallerDelegate.getFieldByName(fieldName);
checkFieldRead(fd, true);
if (primitiveTypes.contains(fd.getType())) {
readPrimitiveCollection(fd, (Collection<Object>) collection, elementClass);
return collection;
}
// todo validate type is compatible with readCollection
final int expectedTag = WireFormat.makeTag(fd.getNumber(), fd.getType().getWireType());
while (true) {
Object o = messageContext.unknownFieldSet.consumeTag(expectedTag);
if (o == null) {
break;
}
byte[] byteArray = (byte[]) o;
RawProtoStreamReader in = RawProtoStreamReaderImpl.newInstance(byteArray);
collection.add(readNestedObject(fd, elementClass, in, byteArray.length));
}
while (true) {
int tag = messageContext.in.readTag();
if (tag == 0) {
break;
}
if (tag == expectedTag) {
collection.add(readNestedObject(fd, elementClass, messageContext.in, -1));
} else {
messageContext.unknownFieldSet.readSingleField(tag, messageContext.in);
}
}
return collection;
}
private <C extends Collection<URI>> C getTypes(Class<?> role, C set) throws RepositoryException {
URI type = of.getNameOf(role);
if (type == null) {
Class<?> superclass = role.getSuperclass();
if (superclass != null) {
getTypes(superclass, set);
}
Class<?>[] interfaces = role.getInterfaces();
for (int i = 0, n = interfaces.length; i < n; i++) {
getTypes(interfaces[i], set);
}
} else {
set.add(type);
}
return set;
}
/**
* 将一个或者多个数组填入一个集合。
*
* @param <C> 集合类型
* @param <T> 数组元素类型
* @param coll 集合
* @param objss 数组 （数目可变）
* @return 集合对象
*/
public static <C extends Collection<T>, T> C fill(C coll, T[]... objss) {
for (T[] objs : objss) for (T obj : objs) coll.add(obj);
return coll;
}
/** {@inheritDoc} */
@Override
public boolean add(final N e) {
return collection.add(funcNtoM.apply(e));
}
/**
* Convert an Object to a Collection with elements of the desired type. If it is a Collection and
* it is of the same collection and element type it is returned as is, otherwise a new Collection
* is created with all elements converted to the desired type. If it is a String representation of
* a Collection it is converted to a Collection.
*
* @param <E> The element type.
* @param <C> The Collection type.
* @param obj The Object to be converted.
* @param collectionType The desired Collection type.
* @param elementType The desired element type.
* @param emptyIfNull Whether or not an empty Collection should be returned if the Collection
* could not be converted.
* @return The converted Collection.
*/
public <E, C extends Collection<E>> C convertToCollection(
Object obj, Class<C> collectionType, Class<E> elementType, boolean emptyIfNull) {
// Grab defaults for types if interfaces or non-datareference collections are provided
Class<? extends C> constructionCollectionType;
Class<? extends E> constructionElementType;
if (collectionType.equals(List.class)) {
if (DataReferencable.class.isAssignableFrom(elementType)) {
constructionCollectionType = (Class) DataReferenceList.class;
constructionElementType = (Class) DataReference.class;
} else {
constructionCollectionType = (Class) ArrayList.class;
}
} else if (collectionType.equals(Set.class)) {
if (DataReferencable.class.isAssignableFrom(elementType)) {
constructionElementType = (Class) DataReference.class;
throw new IllegalArgumentException(
"Set class is not supported for DataReferencable elements");
}
constructionCollectionType = (Class) HashSet.class;
} else {
constructionCollectionType = collectionType;
}
if (obj != null) {
if (obj instanceof Collection) {
// If it's already a collection
Collection collection = (Collection) obj;
Class cachedElementType = getCachedElementType(collection);
// If we have cached it's element type return if same
if (cachedElementType != null
&& elementType.isAssignableFrom(cachedElementType)
&& collection.getClass().equals(constructionCollectionType)) {
setCachedElementType(collection, elementType);
return (C) collection;
} else {
return _convertContents(collection, constructionCollectionType, elementType);
}
} else {
try {
// If it's a single value convertable to E
E e = convert(obj, elementType);
C c = CollectionUtils.instanceOf(constructionCollectionType);
c.add(e);
return c;
} catch (ConversionException ex) {
}
try {
// If it's a string representation of one or many E's
String string = convert(obj, String.class);
String[] split = TextUtils.splitOnSpacesAndCommas(string);
C c = CollectionUtils.instanceOf(constructionCollectionType);
for (String str : split) {
try {
E e = convert(obj, elementType);
c.add(e);
} catch (ConversionException ex) {
}
}
if (!c.isEmpty()) {
return c;
}
} catch (ConversionException ex) {
}
}
}
// Fall through to here if a collection could not be converted for any reason
if (emptyIfNull) {
return CollectionUtils.instanceOf(constructionCollectionType);
} else {
return null;
}
}
@Override
public void readMarshallable(WireIn wire) throws IllegalStateException {
@SuppressWarnings("ConstantConditions")
final Bytes<?> outBytes = outWire.bytes();
try {
final StringBuilder eventName = Wires.acquireStringBuilder();
@SuppressWarnings("ConstantConditions")
final ValueIn valueIn = inWire.readEventName(eventName);
outWire.writeDocument(
true, w -> w.writeEventName(CoreFields.tid).int64(CollectionWireHandler.this.tid));
outWire.writeDocument(
false,
out -> {
// note : remove on the key-set returns a boolean and on the map returns the
// old value
if (EventId.remove.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.remove(fromWire.apply(valueIn)));
return;
}
// note : remove on the key-set returns a boolean and on the map returns the
// old value
if (EventId.iterator.contentEquals(eventName)) {
final ValueOut valueOut = out.writeEventName(CoreFields.reply);
valueOut.sequence(v -> underlyingCollection.forEach(e -> toWire.accept(v, e)));
return;
}
if (EventId.numberOfSegments.contentEquals(eventName)) {
outWire.write(CoreFields.reply).int32(1);
return;
}
if (EventId.isEmpty.contentEquals(eventName)) {
outWire.write(CoreFields.reply).bool(underlyingCollection.isEmpty());
return;
}
if (EventId.size.contentEquals(eventName)) {
outWire.write(CoreFields.reply).int32(underlyingCollection.size());
return;
}
if (EventId.clear.contentEquals(eventName)) {
underlyingCollection.clear();
return;
}
if (EventId.contains.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.contains(fromWire.apply(valueIn)));
return;
}
if (EventId.add.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.add(fromWire.apply(valueIn)));
return;
}
if (EventId.remove.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.remove(fromWire.apply(valueIn)));
return;
}
if (EventId.containsAll.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.remove(collectionFromWire()));
return;
}
if (EventId.addAll.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.addAll(collectionFromWire()));
return;
}
if (EventId.removeAll.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.removeAll(collectionFromWire()));
return;
}
if (EventId.retainAll.contentEquals(eventName)) {
outWire
.write(CoreFields.reply)
.bool(underlyingCollection.retainAll(collectionFromWire()));
return;
}
throw new IllegalStateException("unsupported event=" + eventName);
});
} catch (Exception e) {
LOG.error("", e);
} finally {
if (YamlLogging.showServerWrites) {
long len = outBytes.writePosition();
if (len >= SIZE_OF_SIZE) {
String s = Wires.fromSizePrefixedBlobs(outBytes);
LOG.info("server writes:\n\n" + s);
}
}
}
}
public CollectionBuilder<E, C> add(E e) {
c.add(e);
return this;
}
