package org.ovirt.engine.core.common.businessentities;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* General utility class for common entities functions
*/
public class Entities {
/**
* Map entity's name to entity object. A lot of logic code does filtering of data from 2 collections by quad
* iterating over them. Common scenario: entity Parent.name is represent in Child.parentName. Given
* List<Parent> and List<Child>, find each child that has parents in List<Parent>
* <code>
* List<Parent> parents = ...
* List<Child> childs = ...
* Map<String, Parent> parentsByName = Entities.byName(parents)
* for (Child c : childs) {
* if(parents.contatinsKey(c.getParentName())) {
* doThis();
* }
* }
* }
* </code>
*/
public static <E extends Nameable> Map<String, E> entitiesByName(Collection<E> entities) {
if (entities != null) {
Map<String, E> map = new HashMap<>();
for (E e : entities) {
map.put(e.getName(), e);
}
return map;
} else {
return Collections.emptyMap();
}
}
public static <F extends Serializable, B extends BusinessEntity<F>> Map<F, B> businessEntitiesById(Collection<B> entities) {
if (entities != null) {
Map<F, B> map = new HashMap<>();
for (B b : entities) {
map.put(b.getId(), b);
}
return map;
} else {
return Collections.emptyMap();
}
}
/**
* Convert the given collections to a {@link String}. Empty or <code>null</code> collections will be converted to
* "[]", otherwise first element will appear after the opening bracket, and the consecutive elements (if any) will
* appear on a new line, prefixed by the given prefix.
*
* @param objects The collection to convert (can be <code>null</code>).
* @param prefix The prefix to print on new line of a collection element (not on 1st element).
*
* @return A {@link String} representation of the given collection.
*/
public static String collectionToString(Collection<?> objects, String prefix) {
StringBuilder sb = new StringBuilder("[");
if (objects != null) {
boolean first = true;
for (Iterator<?> iterator = objects.iterator(); iterator.hasNext(); ) {
Object object = iterator.next();
if (first) {
first = false;
} else {
sb.append(prefix);
}
sb.append(object.toString());
if (iterator.hasNext()) {
sb.append(",\n");
}
}
}
sb.append("]");
return sb.toString();
}
/**
* @param requestedIds ids to find.
* @param existingEntities all entities to search among
*
* @return all entities from <code>existingEntities</code> collection, which has complying id.
*/
public static <E extends BusinessEntity<I>, I extends Serializable> List<E> filterEntitiesByRequiredIds(Collection<I> requestedIds,
Collection<E> existingEntities) {
List<E> resultCollection = new ArrayList<>(requestedIds.size());
Map<I, E> existingEntitiesMap = businessEntitiesById(existingEntities);
for (I requestedId : requestedIds) {
if (existingEntitiesMap.containsKey(requestedId)) {
resultCollection.add(existingEntitiesMap.get(requestedId));
}
}
return resultCollection;
}
public static <E extends BusinessEntity<I>, I extends Serializable> List<I> idsNotReferencingExistingRecords(
Collection<I> ids,
Collection<E> existingEntities) {
return idsNotReferencingExistingRecords(ids, businessEntitiesById(existingEntities));
}
public static <E extends BusinessEntity<I>, I extends Serializable> List<I> idsNotReferencingExistingRecords(
Collection<I> ids, Map<I, E> entitiesById) {
List<I> idsNotReferencingExistingRecords = new ArrayList<>();
for (I id : ids) {
if (!entitiesById.containsKey(id)) {
idsNotReferencingExistingRecords.add(id);
}
}
return idsNotReferencingExistingRecords;
}
}