public void formatMultiValue(
final Iterator<?> iIterator, final StringWriter buffer, final String format)
throws IOException {
if (iIterator != null) {
int counter = 0;
String objectJson;
while (iIterator.hasNext()) {
final Object entry = iIterator.next();
if (entry != null) {
if (counter++ > 0) buffer.append(", ");
if (entry instanceof OIdentifiable) {
ORecord<?> rec = ((OIdentifiable) entry).getRecord();
try {
objectJson = rec.getRecord().toJSON(format);
buffer.append(objectJson);
} catch (Exception e) {
OLogManager.instance()
.error(this, "Error transforming record " + rec.getIdentity() + " to JSON", e);
}
} else if (OMultiValue.isMultiValue(entry))
formatMultiValue(OMultiValue.getMultiValueIterator(entry), buffer, format);
else buffer.append(OJSONWriter.writeValue(entry, format));
}
}
}
}
@SuppressWarnings("unchecked")
public void writeResult(Object iResult, final String iFormat)
throws InterruptedException, IOException {
if (iResult == null)
send(
OHttpUtils.STATUS_OK_NOCONTENT_CODE, "", OHttpUtils.CONTENT_TEXT_PLAIN, null, null, true);
else {
if (iResult instanceof Map<?, ?>) {
iResult = ((Map<?, ?>) iResult).entrySet().iterator();
} else if (OMultiValue.isMultiValue(iResult)
&& (OMultiValue.getSize(iResult) > 0
&& !(OMultiValue.getFirstValue(iResult) instanceof OIdentifiable))) {
final List<OIdentifiable> resultSet = new ArrayList<OIdentifiable>();
resultSet.add(new ODocument().field("value", iResult));
iResult = resultSet.iterator();
} else if (iResult instanceof OIdentifiable) {
// CONVERT SIGLE VALUE IN A COLLECTION
final List<OIdentifiable> resultSet = new ArrayList<OIdentifiable>();
resultSet.add((OIdentifiable) iResult);
iResult = resultSet.iterator();
} else if (iResult instanceof Iterable<?>)
iResult = ((Iterable<OIdentifiable>) iResult).iterator();
else if (OMultiValue.isMultiValue(iResult))
iResult = OMultiValue.getMultiValueIterator(iResult);
else {
final List<OIdentifiable> resultSet = new ArrayList<OIdentifiable>();
resultSet.add(new ODocument().field("value", iResult));
iResult = resultSet.iterator();
}
if (iResult == null)
send(
OHttpUtils.STATUS_OK_NOCONTENT_CODE,
"",
OHttpUtils.CONTENT_TEXT_PLAIN,
null,
null,
true);
else if (iResult instanceof Iterator<?>)
writeRecords((Iterator<OIdentifiable>) iResult, null, iFormat);
}
}
@Override
public Object execute(
Object iThis,
OIdentifiable iCurrentRecord,
Object iCurrentResult,
Object[] iParams,
OCommandContext iContext) {
if (iParams[0] instanceof Number) {
addValue((Number) iParams[0]);
} else if (OMultiValue.isMultiValue(iParams[0])) {
for (Object n : OMultiValue.getMultiValueIterable(iParams[0])) {
addValue((Number) n);
}
}
return null;
}
/**
* Returns a Property value.
*
* @param key Property name
* @return Property value if any, otherwise NULL.
*/
@Override
public <T> T getProperty(final String key) {
if (key == null) return null;
final OrientBaseGraph graph = getGraph();
if (key.equals("_class"))
return (T) ODocumentInternal.getImmutableSchemaClass(getRecord()).getName();
else if (key.equals("_version")) return (T) new Integer(getRecord().getVersion());
else if (key.equals("_rid")) return (T) rawElement.getIdentity().toString();
final Object fieldValue = getRecord().field(key);
if (graph != null
&& fieldValue instanceof OIdentifiable
&& !(((OIdentifiable) fieldValue).getRecord() instanceof ORecordBytes))
// CONVERT IT TO VERTEX/EDGE
return (T) graph.getElement(fieldValue);
else if (OMultiValue.isMultiValue(fieldValue)
&& OMultiValue.getFirstValue(fieldValue) instanceof OIdentifiable) {
final OIdentifiable firstValue = (OIdentifiable) OMultiValue.getFirstValue(fieldValue);
if (firstValue instanceof ODocument) {
final ODocument document = (ODocument) firstValue;
if (document.isEmbedded() || ODocumentInternal.getImmutableSchemaClass(document) == null)
return (T) fieldValue;
}
if (graph != null)
// CONVERT IT TO ITERABLE<VERTEX/EDGE>
return (T)
new OrientElementIterable<OrientElement>(
graph, OMultiValue.getMultiValueIterable(fieldValue));
}
return (T) fieldValue;
}
protected static boolean comparesValues(
final Object iValue, final ORecord<?> iRecord, final boolean iConsiderIn) {
// ORID && RECORD
final ORID other = ((ORecord<?>) iRecord).getIdentity();
if (!other.isPersistent() && iRecord instanceof ODocument) {
// ODOCUMENT AS RESULT OF SUB-QUERY: GET THE FIRST FIELD IF ANY
final String[] firstFieldName = ((ODocument) iRecord).fieldNames();
if (firstFieldName.length > 0) {
Object fieldValue = ((ODocument) iRecord).field(firstFieldName[0]);
if (fieldValue != null) {
if (iConsiderIn && OMultiValue.isMultiValue(fieldValue)) {
for (Object o : OMultiValue.getMultiValueIterable(fieldValue)) {
if (o != null && o.equals(iValue)) return true;
}
}
return fieldValue.equals(iValue);
}
}
return false;
}
return other.equals(iValue);
}
@SuppressWarnings("unchecked")
private static void fetchCollection(
final ORecordSchemaAware<?> iRootRecord,
final Object iUserObject,
final Map<String, Integer> iFetchPlan,
final Object fieldValue,
final String fieldName,
final int iCurrentLevel,
final int iLevelFromRoot,
final int iFieldDepthLevel,
final Map<ORID, Integer> parsedRecords,
final String iFieldPathFromRoot,
final OFetchListener iListener,
final OFetchContext iContext)
throws IOException {
final Collection<?> linked;
if (fieldValue instanceof ODocument)
linked = new OMVRBTreeRIDSet().fromDocument((ODocument) fieldValue);
else if (fieldValue instanceof Collection<?>) {
linked = (Collection<OIdentifiable>) fieldValue;
iContext.onBeforeCollection(iRootRecord, fieldName, iUserObject, linked);
} else if (fieldValue instanceof Map<?, ?>) {
linked = (Collection<?>) ((Map<?, ?>) fieldValue).values();
iContext.onBeforeMap(iRootRecord, fieldName, iUserObject);
} else throw new IllegalStateException("Unrecognized type: " + fieldValue.getClass());
final Iterator<?> iter;
if (linked instanceof ORecordLazyMultiValue)
iter = ((ORecordLazyMultiValue) linked).rawIterator();
else iter = linked.iterator();
while (iter.hasNext()) {
final Object o = iter.next();
if (o == null) continue;
if (o instanceof OIdentifiable) {
OIdentifiable d = (OIdentifiable) o;
// GO RECURSIVELY
final Integer fieldDepthLevel = parsedRecords.get(d.getIdentity());
if (!d.getIdentity().isValid()
|| (fieldDepthLevel != null && fieldDepthLevel.intValue() == iLevelFromRoot)) {
removeParsedFromMap(parsedRecords, d);
d = d.getRecord();
if (!(d instanceof ODocument)) {
iListener.processStandardField(null, d, fieldName, iContext, iUserObject, "");
} else {
iContext.onBeforeDocument(iRootRecord, (ODocument) d, fieldName, iUserObject);
final Object userObject =
iListener.fetchLinkedCollectionValue(
iRootRecord, iUserObject, fieldName, (ODocument) d, iContext);
processRecord(
(ODocument) d,
userObject,
iFetchPlan,
iCurrentLevel,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext,
"");
iContext.onAfterDocument(iRootRecord, (ODocument) d, fieldName, iUserObject);
}
} else {
iListener.parseLinkedCollectionValue(iRootRecord, d, iUserObject, fieldName, iContext);
}
} else if (o instanceof Map<?, ?>) {
fetchMap(
iRootRecord,
iUserObject,
iFetchPlan,
o,
null,
iCurrentLevel + 1,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext);
} else if (OMultiValue.isMultiValue(o)) {
fetchCollection(
iRootRecord,
iUserObject,
iFetchPlan,
o,
null,
iCurrentLevel + 1,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext);
}
}
if (fieldValue instanceof Collection<?>)
iContext.onAfterCollection(iRootRecord, fieldName, iUserObject);
else if (fieldValue instanceof Map<?, ?>)
iContext.onAfterMap(iRootRecord, fieldName, iUserObject);
}
@SuppressWarnings("unchecked")
private static void fetchMap(
final ORecordSchemaAware<?> iRootRecord,
final Object iUserObject,
final Map<String, Integer> iFetchPlan,
Object fieldValue,
String fieldName,
final int iCurrentLevel,
final int iLevelFromRoot,
final int iFieldDepthLevel,
final Map<ORID, Integer> parsedRecords,
final String iFieldPathFromRoot,
final OFetchListener iListener,
final OFetchContext iContext)
throws IOException {
final Map<String, ODocument> linked = (Map<String, ODocument>) fieldValue;
iContext.onBeforeMap(iRootRecord, fieldName, iUserObject);
for (Object key : linked.keySet()) {
final Object o = linked.get(key);
if (o instanceof OIdentifiable) {
final ODocument d = ((OIdentifiable) o).getRecord();
if (d != null) {
// GO RECURSIVELY
final Integer fieldDepthLevel = parsedRecords.get(d.getIdentity());
if (!d.getIdentity().isValid()
|| (fieldDepthLevel != null && fieldDepthLevel.intValue() == iLevelFromRoot)) {
removeParsedFromMap(parsedRecords, d);
iContext.onBeforeDocument(iRootRecord, d, key.toString(), iUserObject);
final Object userObject =
iListener.fetchLinkedMapEntry(
iRootRecord, iUserObject, fieldName, key.toString(), d, iContext);
processRecord(
d,
userObject,
iFetchPlan,
iCurrentLevel,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext,
"");
iContext.onAfterDocument(iRootRecord, d, key.toString(), iUserObject);
} else {
iListener.parseLinked(iRootRecord, d, iUserObject, key.toString(), iContext);
}
}
} else if (o instanceof Map) {
fetchMap(
iRootRecord,
iUserObject,
iFetchPlan,
o,
key.toString(),
iCurrentLevel + 1,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext);
} else if (OMultiValue.isMultiValue(o)) {
fetchCollection(
iRootRecord,
iUserObject,
iFetchPlan,
o,
key.toString(),
iCurrentLevel + 1,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext);
} else
iListener.processStandardField(iRootRecord, o, key.toString(), iContext, iUserObject, "");
}
iContext.onAfterMap(iRootRecord, fieldName, iUserObject);
}
