org.usergrid.persistence.Results Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of usergrid-core Show documentation
Show all versions of usergrid-core Show documentation
Core services for Usergrid system.
/*******************************************************************************
* Copyright 2012 Apigee Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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.
******************************************************************************/
package org.usergrid.persistence;
import static org.apache.commons.codec.binary.Base64.encodeBase64URLSafeString;
import static org.usergrid.persistence.SimpleEntityRef.ref;
import static org.usergrid.utils.ClassUtils.cast;
import static org.usergrid.utils.CompositeUtils.setEqualityFlag;
import static org.usergrid.utils.ConversionUtils.bytes;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.Map.Entry;
import javax.xml.bind.annotation.XmlRootElement;
import me.prettyprint.hector.api.beans.DynamicComposite;
import me.prettyprint.hector.api.beans.AbstractComposite.ComponentEquality;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
import org.usergrid.persistence.query.ir.QuerySlice.RangeValue;
import org.usergrid.utils.MapUtils;
import org.usergrid.utils.StringUtils;
@XmlRootElement
public class Results implements Iterable {
private static final String EMPTY = "";
public enum Level {
IDS, REFS, CORE_PROPERTIES, ALL_PROPERTIES, LINKED_PROPERTIES
}
Level level = Level.IDS;
UUID id;
List ids;
Set idSet;
EntityRef ref;
List refs;
Map refsMap;
Map> refsByType;
Entity entity;
List entities;
Map entitiesMap;
Map> entitiesByType;
List connections;
boolean forwardConnections = true;
List counters;
Set types;
Map> metadata;
boolean metadataMerged = true;
UUID nextResult;
String cursor;
Query query;
Object data;
String dataName;
public Results() {
}
public Results(Results r) {
if (r != null) {
id = r.id;
ids = r.ids;
idSet = r.idSet;
ref = r.ref;
refs = r.refs;
refsMap = r.refsMap;
refsByType = r.refsByType;
entity = r.entity;
entities = r.entities;
entitiesMap = r.entitiesMap;
entitiesByType = r.entitiesByType;
connections = r.connections;
forwardConnections = r.forwardConnections;
counters = r.counters;
types = r.types;
metadata = r.metadata;
metadataMerged = r.metadataMerged;
nextResult = r.nextResult;
cursor = r.cursor;
query = r.query;
data = r.data;
dataName = r.dataName;
}
}
public void init() {
level = Level.IDS;
id = null;
ids = null;
idSet = null;
ref = null;
refs = null;
refsMap = null;
refsByType = null;
entity = null;
entities = null;
entitiesMap = null;
entitiesByType = null;
connections = null;
forwardConnections = true;
counters = null;
types = null;
// metadata = null;
metadataMerged = false;
query = null;
data = null;
dataName = null;
}
public static Results fromIdList(List l) {
Results r = new Results();
r.setIds(l);
return r;
}
public static Results fromIdList(List l, String type) {
if (type == null) {
return fromIdList(l);
}
List refs = new ArrayList();
for (UUID u : l) {
refs.add(ref(type, u));
}
Results r = new Results();
r.setRefs(refs);
return r;
}
public static Results fromId(UUID id) {
Results r = new Results();
if (id != null) {
List l = new ArrayList();
l.add(id);
r.setIds(l);
}
return r;
}
public static Results fromRefList(List l) {
Results r = new Results();
r.setRefs(l);
return r;
}
public static Results fromEntities(List l) {
Results r = new Results();
r.setEntities(l);
return r;
}
public static Results fromEntity(Entity e) {
Results r = new Results();
r.setEntity(e);
return r;
}
public static Results fromRef(EntityRef ref) {
if (ref instanceof Entity) {
return fromEntity((Entity) ref);
}
Results r = new Results();
r.setRef(ref);
return r;
}
public static Results fromData(Object obj) {
Results r = new Results();
r.setData(obj);
return r;
}
public static Results fromCounters(AggregateCounterSet counters) {
Results r = new Results();
List l = new ArrayList();
l.add(counters);
r.setCounters(l);
return r;
}
public static Results fromCounters(List counters) {
Results r = new Results();
r.setCounters(counters);
return r;
}
@SuppressWarnings("unchecked")
public static Results fromConnections(
List connections) {
Results r = new Results();
r.setConnections((List) connections, true);
return r;
}
@SuppressWarnings("unchecked")
public static Results fromConnections(
List connections, boolean forward) {
Results r = new Results();
r.setConnections((List) connections, forward);
return r;
}
public Level getLevel() {
return level;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Query getQuery() {
return query;
}
public void setQuery(Query query) {
this.query = query;
}
public Results withQuery(Query query) {
this.query = query;
return this;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public UUID getId() {
if (id != null) {
return id;
}
if (entity != null) {
id = entity.getUuid();
return id;
}
if ((ids != null) && (ids.size() > 0)) {
id = ids.get(0);
return id;
}
if ((entities != null) && (entities.size() > 0)) {
entity = entities.get(0);
id = entity.getUuid();
return id;
}
if ((refs != null) && (refs.size() > 0)) {
EntityRef ref = refs.get(0);
id = ref.getUuid();
}
return id;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public List getIds() {
if (ids != null) {
return ids;
}
/*
* if (connectionTypeAndEntityTypeToEntityIdMap != null) { ids = new
* ArrayList(); Set entitySet = new LinkedHashSet();
* for (String ctype : connectionTypeAndEntityTypeToEntityIdMap
* .keySet()) { Map> m =
* connectionTypeAndEntityTypeToEntityIdMap .get(ctype); for (String
* etype : m.keySet()) { List l = m.get(etype); for (UUID id : l)
* { if (!entitySet.contains(id)) { ids.add(id); } } } } return ids; }
*/
if (connections != null) {
ids = new ArrayList();
for (ConnectionRef connection : connections) {
if (forwardConnections) {
ConnectedEntityRef c = connection.getConnectedEntity();
if (c != null) {
ids.add(c.getUuid());
}
} else {
EntityRef c = connection.getConnectingEntity();
if (c != null) {
ids.add(c.getUuid());
}
}
}
return ids;
}
if ((entities != null)
/* || (connectionTypeAndEntityTypeToEntityMap != null) */) {
// getEntities();
ids = new ArrayList();
for (Entity entity : entities) {
ids.add(entity.getUuid());
}
return ids;
}
if (refs != null) {
ids = new ArrayList();
for (EntityRef ref : refs) {
ids.add(ref.getUuid());
}
return ids;
}
if (id != null) {
ids = new ArrayList();
ids.add(id);
return ids;
}
if (entity != null) {
ids = new ArrayList();
ids.add(entity.getUuid());
return ids;
}
return new ArrayList();
}
public void setIds(List resultsIds) {
init();
ids = resultsIds;
level = Level.IDS;
}
public Results withIds(List resultsIds) {
setIds(resultsIds);
return this;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Set getIdSet() {
if (idSet != null) {
return idSet;
}
getIds();
if (ids != null) {
idSet = new LinkedHashSet();
idSet.addAll(ids);
return idSet;
}
return new LinkedHashSet();
}
@JsonSerialize(include = Inclusion.NON_NULL)
@SuppressWarnings("unchecked")
public List getRefs() {
if (refs != null) {
return refs;
}
List l = getEntities();
if ((l != null) && (l.size() > 0)) {
return (List) l;
}
if (connections != null) {
refs = new ArrayList();
for (ConnectionRef connection : connections) {
if (forwardConnections) {
ConnectedEntityRef c = connection.getConnectedEntity();
if (c != null) {
refs.add(c);
}
} else {
EntityRef c = connection.getConnectingEntity();
if (c != null) {
refs.add(c);
}
}
}
return refs;
}
if (ref != null) {
refs = new ArrayList();
refs.add(ref);
return refs;
}
return new ArrayList();
}
public void setRefs(List resultsRefs) {
init();
refs = resultsRefs;
level = Level.REFS;
}
public Results withRefs(List resultsRefs) {
setRefs(resultsRefs);
return this;
}
public void setRef(EntityRef ref) {
init();
this.ref = ref;
level = Level.REFS;
}
public Results withRef(EntityRef ref) {
setRef(ref);
return this;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public EntityRef getRef() {
if (ref != null) {
return ref;
}
ref = getEntity();
if (ref != null) {
return ref;
}
UUID u = getId();
if (u != null) {
return ref(u);
}
return null;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Map getRefsMap() {
if (refsMap != null) {
return refsMap;
}
getEntitiesMap();
if (entitiesMap != null) {
refsMap = cast(entitiesMap);
return refsMap;
}
getRefs();
if (refs != null) {
refsMap = new LinkedHashMap();
for (EntityRef ref : refs) {
refsMap.put(ref.getUuid(), ref);
}
}
return refsMap;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Entity getEntity() {
mergeEntitiesWithMetadata();
if (entity != null) {
return entity;
}
if ((entities != null) && (entities.size() > 0)) {
entity = entities.get(0);
return entity;
}
return null;
}
public void setEntity(Entity resultEntity) {
init();
entity = resultEntity;
level = Level.CORE_PROPERTIES;
}
public Results withEntity(Entity resultEntity) {
setEntity(resultEntity);
return this;
}
public Iterator idIterator() {
List l = getIds();
if (l != null) {
return l.iterator();
}
return (new ArrayList(0)).iterator();
}
@JsonSerialize(include = Inclusion.NON_NULL)
public List getEntities() {
mergeEntitiesWithMetadata();
if (entities != null) {
return entities;
}
/*
* if (connectionTypeAndEntityTypeToEntityMap != null) { entities = new
* ArrayList(); Map eMap = new LinkedHashMap(); for (String ctype :
* connectionTypeAndEntityTypeToEntityMap.keySet()) { Map> m = connectionTypeAndEntityTypeToEntityMap .get(ctype);
* for (String etype : m.keySet()) { List l = m.get(etype); for
* (Entity e : l) { if (!eMap.containsKey(e.getId())) { entities.add(e);
* eMap.put(e.getId(), e); } } } } return entities; }
*/
if (entity != null) {
entities = new ArrayList();
entities.add(entity);
return entities;
}
return new ArrayList();
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Map getEntitiesMap() {
if (entitiesMap != null) {
return entitiesMap;
}
if (entities != null) {
entitiesMap = new LinkedHashMap();
for (Entity entity : entities) {
entitiesMap.put(entity.getUuid(), entity);
}
}
return entitiesMap;
}
public List getEntityRefsByType(String type) {
if (entitiesByType != null) {
return refsByType.get(type);
}
List l = cast(getEntitiesByType(type));
if (l != null) {
return l;
}
getRefs();
if (refs == null) {
return null;
}
refsByType = new LinkedHashMap>();
for (Entity entity : entities) {
l = refsByType.get(entity.getType());
if (l == null) {
l = new ArrayList();
refsByType.put(entity.getType(), l);
}
l.add(entity);
}
return l;
}
public List getEntitiesByType(String type) {
if (entitiesByType != null) {
return entitiesByType.get(type);
}
getEntities();
if (entities == null) {
return null;
}
List l = null;
entitiesByType = new LinkedHashMap>();
for (Entity entity : entities) {
l = entitiesByType.get(entity.getType());
if (l == null) {
l = new ArrayList();
entitiesByType.put(entity.getType(), l);
}
l.add(entity);
}
return l;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Set getTypes() {
if (types != null) {
return types;
}
getEntityRefsByType("entity");
if (entitiesByType != null) {
types = entitiesByType.keySet();
} else if (refsByType != null) {
types = refsByType.keySet();
}
return types;
}
public void merge(Results results) {
getEntitiesMap();
results.getEntitiesMap();
if (entitiesMap != null || results.entitiesMap != null) {
level = Level.ALL_PROPERTIES;
// do nothing, nothing to union
if (entitiesMap != null && results.entitiesMap == null) {
return;
// other side has the results, assign and return
} else if (entitiesMap == null && results.entitiesMap != null) {
entities = results.entities;
return;
}
entitiesMap.putAll(results.entitiesMap);
entities = new ArrayList(entitiesMap.values());
return;
}
getRefsMap();
results.getRefsMap();
if ((refsMap != null) || (results.refsMap != null)) {
level = Level.REFS;
// do nothing, nothing to union
if (refsMap != null && results.refsMap == null) {
return;
// other side has the results, assign and return
} else if (refsMap == null && results.refsMap != null) {
refs = results.refs;
return;
}
refsMap.putAll(results.refsMap);
refs = new ArrayList(refsMap.values());
return;
}
getIdSet();
results.getIdSet();
if ((idSet != null) && (results.idSet != null)) {
level = Level.IDS;
// do nothing, nothing to union
if (idSet != null && results.idSet == null) {
return;
// other side has the results, assign and return
} else if (idSet == null && results.idSet != null) {
ids = results.ids;
return;
}
idSet.addAll(results.idSet);
ids = new ArrayList(idSet);
return;
}
}
/**
* Remove the passed in results from the current results
*
* @param results
*/
public void subtract(Results results) {
getEntitiesMap();
results.getEntitiesMap();
if ((entitiesMap != null) && (results.entitiesMap != null)) {
Map newMap = new LinkedHashMap();
for (Map.Entry e : entitiesMap.entrySet()) {
if (!results.entitiesMap.containsKey(e.getKey())) {
newMap.put(e.getKey(), e.getValue());
}
}
entitiesMap = newMap;
entities = new ArrayList(entitiesMap.values());
level = Level.ALL_PROPERTIES;
return;
}
getRefsMap();
results.getRefsMap();
if ((refsMap != null) && (results.refsMap != null)) {
Map newMap = new LinkedHashMap();
for (Map.Entry e : refsMap.entrySet()) {
if (!results.refsMap.containsKey(e.getKey())) {
newMap.put(e.getKey(), e.getValue());
}
}
refsMap = newMap;
refs = new ArrayList(refsMap.values());
level = Level.REFS;
return;
}
getIdSet();
results.getIdSet();
if ((idSet != null) && (results.idSet != null)) {
Set newSet = new LinkedHashSet();
for (UUID uuid : idSet) {
if (!results.idSet.contains(uuid)) {
newSet.add(uuid);
}
}
idSet = newSet;
ids = new ArrayList(idSet);
level = Level.IDS;
return;
}
}
/**
* Perform an intersection of the 2 results
*
* @param results
*/
public void and(Results results) {
getEntitiesMap();
results.getEntitiesMap();
if ((entitiesMap != null) && (results.entitiesMap != null)) {
Map newMap = new LinkedHashMap();
for (Map.Entry e : entitiesMap.entrySet()) {
if (results.entitiesMap.containsKey(e.getKey())) {
newMap.put(e.getKey(), e.getValue());
}
}
entitiesMap = newMap;
entities = new ArrayList(entitiesMap.values());
level = Level.ALL_PROPERTIES;
return;
}
getRefsMap();
results.getRefsMap();
if ((refsMap != null) && (results.refsMap != null)) {
Map newMap = new LinkedHashMap();
for (Map.Entry e : refsMap.entrySet()) {
if (results.refsMap.containsKey(e.getKey())) {
newMap.put(e.getKey(), e.getValue());
}
}
refsMap = newMap;
refs = new ArrayList(refsMap.values());
level = Level.REFS;
ids = null;
return;
}
getIdSet();
results.getIdSet();
if ((idSet != null) && (results.idSet != null)) {
Set newSet = new LinkedHashSet();
for (UUID uuid : idSet) {
if (results.idSet.contains(uuid)) {
newSet.add(uuid);
}
}
idSet = newSet;
ids = new ArrayList(idSet);
level = Level.IDS;
return;
}
// should be empty
init();
}
public void replace(Entity entity) {
entitiesMap = null;
if ((this.entity != null)
&& (this.entity.getUuid().equals(entity.getUuid()))) {
this.entity = entity;
}
if (entities != null) {
ListIterator i = entities.listIterator();
while (i.hasNext()) {
Entity e = i.next();
if (e.getUuid().equals(entity.getUuid())) {
i.set(entity);
}
}
}
}
public Results startingFrom(UUID entityId) {
if (entities != null) {
for (int i = 0; i < entities.size(); i++) {
Entity entity = entities.get(i);
if (entityId.equals(entity.getUuid())) {
if (i == 0) {
return this;
}
return Results.fromEntities(entities.subList(i,
entities.size()));
}
}
}
if (refs != null) {
for (int i = 0; i < refs.size(); i++) {
EntityRef entityRef = refs.get(i);
if (entityId.equals(entityRef.getUuid())) {
if (i == 0) {
return this;
}
return Results.fromRefList(refs.subList(i, refs.size()));
}
}
}
if (ids != null) {
for (int i = 0; i < ids.size(); i++) {
UUID uuid = ids.get(i);
if (entityId.equals(uuid)) {
if (i == 0) {
return this;
}
return Results.fromIdList(ids.subList(i, ids.size()));
}
}
}
return this;
}
@SuppressWarnings("unchecked")
@JsonSerialize(include = Inclusion.NON_NULL)
public List getList() {
List l = getEntities();
return (List) l;
}
public Iterator iterator(Class cls) {
List l = getList();
if (l != null) {
return l.iterator();
}
return (new ArrayList(0)).iterator();
}
@Override
public Iterator iterator() {
List l = getEntities();
if (l != null) {
return l.iterator();
}
return (new ArrayList(0)).iterator();
}
public Results findForProperty(String propertyName, Object propertyValue) {
return findForProperty(propertyName, propertyValue, 1);
}
public Results findForProperty(String propertyName, Object propertyValue,
int count) {
if (propertyValue == null) {
return new Results();
}
List l = getEntities();
if (l == null) {
return new Results();
}
List found = new ArrayList();
for (Entity e : l) {
if (propertyValue.equals(e.getProperty(propertyName))) {
found.add(e);
if ((count > 0) && (found.size() == count)) {
break;
}
}
}
return Results.fromEntities(found);
}
@SuppressWarnings("unchecked")
public void setEntities(List resultsEntities) {
init();
entities = (List) resultsEntities;
level = Level.CORE_PROPERTIES;
}
public Results withEntities(List resultsEntities) {
setEntities(resultsEntities);
return this;
}
public boolean hasConnections() {
return connections != null;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public List getConnections() {
return connections;
}
private void setConnections(List connections,
boolean forwardConnections) {
init();
this.connections = connections;
this.forwardConnections = forwardConnections;
level = Level.REFS;
for (ConnectionRef connection : connections) {
if (forwardConnections) {
this.setMetadata(connection.getConnectedEntity().getUuid(),
"connection", connection.getConnectionType());
} else {
this.setMetadata(connection.getConnectingEntity().getUuid(),
"connection", connection.getConnectionType());
}
}
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Object getObject() {
if (data != null) {
return data;
}
if (entities != null) {
return entities;
}
if (ids != null) {
return ids;
}
if (entity != null) {
return entity;
}
if (id != null) {
return id;
}
if (counters != null) {
return counters;
}
return null;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public String getObjectName() {
if (dataName != null) {
return dataName;
}
if (entities != null) {
return "entities";
}
if (ids != null) {
return "ids";
}
if (entity != null) {
return "entity";
}
if (id != null) {
return "id";
}
return null;
}
public void setDataName(String dataName) {
this.dataName = dataName;
}
public Results withDataName(String dataName) {
this.dataName = dataName;
return this;
}
public boolean hasData() {
return data != null;
}
public void setData(Object data) {
this.data = data;
}
public Results withData(Object data) {
this.data = data;
return this;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public Object getData() {
return data;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public List getCounters() {
return counters;
}
public void setCounters(List counters) {
this.counters = counters;
}
public Results withCounters(List counters) {
this.counters = counters;
return this;
}
public int size() {
if (entities != null) {
return entities.size();
}
if (refs != null) {
return refs.size();
}
if (ids != null) {
return ids.size();
}
if (entity != null) {
return 1;
}
if (ref != null) {
return 1;
}
if (id != null) {
return 1;
}
return 0;
}
public boolean isEmpty() {
return size() == 0;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public UUID getNextResult() {
return nextResult;
}
public Results excludeCursorMetadataAttribute() {
if (metadata != null) {
for (Entry> entry : metadata.entrySet()) {
Map map = entry.getValue();
if(map!=null) {
map.remove(Schema.PROPERTY_CURSOR);
}
}
}
return new Results(this);
}
public Results trim(int count) {
if (count == 0) {
return this;
}
int size = size();
if (size <= count) {
return this;
}
List ids = getIds();
UUID nextResult = null;
String cursor = null;
if (ids.size() > count) {
nextResult = ids.get(count);
ids = ids.subList(0, count);
if (metadata != null) {
cursor = StringUtils.toString(MapUtils.getMapMap(metadata,
nextResult, "cursor"));
}
if (cursor == null) {
cursor = encodeBase64URLSafeString(bytes(nextResult));
}
}
Results r = new Results(this);
if (r.entities != null) {
r.entities = r.entities.subList(0, count);
}
if (r.refs != null) {
r.refs = r.refs.subList(0, count);
}
if (r.ids != null) {
r.ids = r.ids.subList(0, count);
}
r.setNextResult(nextResult);
r.setCursor(cursor);
return r;
}
public boolean hasMoreResults() {
return nextResult != null;
}
public void setNextResult(UUID nextResult) {
this.nextResult = nextResult;
}
public Results withNextResult(UUID nextResult) {
this.nextResult = nextResult;
return this;
}
@JsonSerialize(include = Inclusion.NON_NULL)
public String getCursor() {
return cursor;
}
public void setCursorToLastResult() {
List ids = getIds();
if ((ids != null) && (metadata != null) && (ids.size() > 0)) {
UUID lastId = ids.get(ids.size() - 1);
cursor = StringUtils.toString(MapUtils.getMapMap(metadata, lastId,
"cursor"));
}
}
/**
* Set the cursor to the empty value. This signifies that no more results can be found for this range
*/
public void setCursorMax() {
cursor = EMPTY;
}
public void setCursor(String cursor) {
this.cursor = cursor;
}
public Results withCursor(String cursor) {
this.cursor = cursor;
return this;
}
public void setMetadata(UUID id, String name, Object value) {
if (metadata == null) {
metadata = new LinkedHashMap>();
}
Map entityMetadata = metadata.get(id);
if (entityMetadata == null) {
entityMetadata = new LinkedHashMap();
metadata.put(id, entityMetadata);
}
entityMetadata.put(name, value);
metadataMerged = false;
// updateIndex(id, name, value);
}
public Results withMetadata(UUID id, String name, Object value) {
setMetadata(id, name, value);
return this;
}
public void setMetadata(UUID id, Map data) {
if (metadata == null) {
metadata = new LinkedHashMap>();
}
Map entityMetadata = metadata.get(id);
if (entityMetadata == null) {
entityMetadata = new LinkedHashMap();
metadata.put(id, entityMetadata);
}
entityMetadata.putAll(data);
metadataMerged = false;
/*
* for (Entry m : data.entrySet()) { updateIndex(id,
* m.getKey(), m.getValue()); }
*/
}
public Results withMetadata(UUID id, Map data) {
setMetadata(id, data);
return this;
}
public void setMetadata(Map> metadata) {
this.metadata = metadata;
}
public Results withMetadata(Map> metadata) {
this.metadata = metadata;
return this;
}
public void mergeEntitiesWithMetadata() {
if (metadataMerged) {
return;
}
if (metadata == null) {
return;
}
metadataMerged = true;
getEntities();
if (entities != null) {
for (Entity entity : entities) {
entity.clearMetadata();
Map entityMetadata = metadata.get(entity
.getUuid());
if (entityMetadata != null) {
entity.mergeMetadata(entityMetadata);
}
}
}
}
}