org.elasticsearch.common.xcontent.XContentGenerator Java Examples

/**
 * Create Elasticsearch document source content from entity
 *
 * @param entity the entity to convert to document source content
 * @return Elasticsearch document source content
 */
Document createDocument(Entity entity) {
  int maxIndexingDepth = entity.getEntityType().getIndexingDepth();
  XContentBuilder contentBuilder;
  try {
    contentBuilder = XContentFactory.contentBuilder(JSON);
    XContentGenerator generator = contentBuilder.generator();
    generator.writeStartObject();
    createRec(entity, generator, 0, maxIndexingDepth);
    generator.writeEndObject();
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
  String documentId = toElasticsearchId(entity.getIdValue());
  return Document.create(documentId, contentBuilder);
}
 

private void writeBoolean(XContentGenerator generator, Boolean boolValue) throws IOException {
  if (boolValue != null) {
    generator.writeBoolean(boolValue);
  } else {
    generator.writeNull();
  }
}
 

private void writeDouble(XContentGenerator generator, Double doubleValue) throws IOException {
  if (doubleValue != null) {
    generator.writeNumber(doubleValue);
  } else {
    generator.writeNull();
  }
}
 

private void writeInteger(XContentGenerator generator, Integer intValue) throws IOException {
  if (intValue != null) {
    generator.writeNumber(intValue);
  } else {
    generator.writeNull();
  }
}
 

private void writeLong(XContentGenerator generator, Long longValue) throws IOException {
  if (longValue != null) {
    generator.writeNumber(longValue);
  } else {
    generator.writeNull();
  }
}
 

private void writeDateTime(XContentGenerator generator, Instant dateTimeValue)
    throws IOException {
  if (dateTimeValue != null) {
    generator.writeString(dateTimeValue.toString());
  } else {
    generator.writeNull();
  }
}
 

private void writeDate(XContentGenerator generator, LocalDate dateValue) throws IOException {
  if (dateValue != null) {
    generator.writeString(dateValue.toString());
  } else {
    generator.writeNull();
  }
}
 

private void writeString(XContentGenerator generator, String strValue) throws IOException {
  if (strValue != null) {
    generator.writeString(strValue);
  } else {
    generator.writeNull();
  }
}
 

private void writeReference(
    XContentGenerator generator, int depth, int maxDepth, Entity xrefEntity) throws IOException {
  if (xrefEntity != null) {
    createRecReferenceAttribute(generator, depth, maxDepth, xrefEntity);
  } else {
    generator.writeNull();
  }
}
 

private void writeMultiReference(
    XContentGenerator generator, int depth, int maxDepth, Iterable<Entity> mrefEntities)
    throws IOException {
  if (!Iterables.isEmpty(mrefEntities)) {
    generator.writeStartArray();
    for (Entity mrefEntity : mrefEntities) {
      createRecReferenceAttribute(generator, depth, maxDepth, mrefEntity);
    }
    generator.writeEndArray();
  } else {
    generator.writeNull();
  }
}
 

private void createRec(Entity entity, XContentGenerator generator, int depth, int maxDepth)
    throws IOException {
  for (Attribute attr : entity.getEntityType().getAtomicAttributes()) {
    generator.writeFieldName(documentIdGenerator.generateId(attr));
    createRec(entity, attr, generator, depth, maxDepth);
  }
}
 

private void createRecReferenceAttribute(
    XContentGenerator generator, int depth, int maxDepth, Entity xrefEntity) throws IOException {
  if (depth < maxDepth) {
    generator.writeStartObject();
    createRec(xrefEntity, generator, depth + 1, maxDepth);
    generator.writeEndObject();
  } else {
    Attribute xrefIdAttr = xrefEntity.getEntityType().getLabelAttribute();
    createRec(xrefEntity, xrefIdAttr, generator, depth + 1, maxDepth);
  }
}
 

/**
 * Low level implementation detail of {@link XContentGenerator#copyCurrentStructure(XContentParser)}.
 */
private static void copyCurrentStructure(XContentGenerator destination, XContentParser parser) throws IOException {
    XContentParser.Token token = parser.currentToken();

    // Let's handle field-name separately first
    if (token == XContentParser.Token.FIELD_NAME) {
        destination.writeFieldName(parser.currentName());
        token = parser.nextToken();
        // fall-through to copy the associated value
    }

    switch (token) {
        case START_ARRAY:
            destination.writeStartArray();
            while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                copyCurrentStructure(destination, parser);
            }
            destination.writeEndArray();
            break;
        case START_OBJECT:
            destination.writeStartObject();
            while (parser.nextToken() != XContentParser.Token.END_OBJECT) {
                copyCurrentStructure(destination, parser);
            }
            destination.writeEndObject();
            break;
        default: // others are simple:
            destination.copyCurrentEvent(parser);
    }
}
 

public static void copyCurrentStructure(XContentGenerator generator, XContentParser parser) throws IOException {
    XContentParser.Token t = parser.currentToken();

    // Let's handle field-name separately first
    if (t == XContentParser.Token.FIELD_NAME) {
        generator.writeFieldName(parser.currentName());
        t = parser.nextToken();
        // fall-through to copy the associated value
    }

    switch (t) {
        case START_ARRAY:
            generator.writeStartArray();
            while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                copyCurrentStructure(generator, parser);
            }
            generator.writeEndArray();
            break;
        case START_OBJECT:
            generator.writeStartObject();
            while (parser.nextToken() != XContentParser.Token.END_OBJECT) {
                copyCurrentStructure(generator, parser);
            }
            generator.writeEndObject();
            break;
        default: // others are simple:
            copyCurrentEvent(generator, parser);
    }
}
 

@Override
public XContentGenerator createGenerator(OutputStream os, Set<String> includes, Set<String> excludes) throws IOException {
    return new SmileXContentGenerator(SMILE_FACTORY.createGenerator(os, JsonEncoding.UTF8), os, includes, excludes);
}
 

@Override
public XContentGenerator createGenerator(OutputStream os, Set<String> includes, Set<String> excludes) throws IOException {
    return new YamlXContentGenerator(YAML_FACTORY.createGenerator(os, JsonEncoding.UTF8), os, includes, excludes);
}
 

@Override
public XContentGenerator createGenerator(OutputStream os, Set<String> includes, Set<String> excludes) throws IOException {
    return new JsonXContentGenerator(JSON_FACTORY.createGenerator(os, JsonEncoding.UTF8), os, includes, excludes);
}
 

@Override
public XContentGenerator createGenerator(OutputStream os) throws IOException {
    return new XmlXContentGenerator(xmlFactory.createGenerator(os, JsonEncoding.UTF8));
}
 

private void createRec(
    Entity entity, Attribute attr, XContentGenerator generator, int depth, int maxDepth)
    throws IOException {
  String attrName = attr.getName();
  AttributeType attrType = attr.getDataType();

  switch (attrType) {
    case BOOL:
      Boolean boolValue = entity.getBoolean(attrName);
      writeBoolean(generator, boolValue);
      break;
    case DECIMAL:
      Double doubleValue = entity.getDouble(attrName);
      writeDouble(generator, doubleValue);
      break;
    case INT:
      Integer intValue = entity.getInt(attrName);
      writeInteger(generator, intValue);
      break;
    case LONG:
      Long longValue = entity.getLong(attrName);
      writeLong(generator, longValue);
      break;
    case EMAIL:
    case ENUM:
    case HTML:
    case HYPERLINK:
    case SCRIPT:
    case STRING:
    case TEXT:
      String strValue = entity.getString(attrName);
      writeString(generator, strValue);
      break;
    case DATE:
      LocalDate date = entity.getLocalDate(attrName);
      writeDate(generator, date);
      break;
    case DATE_TIME:
      Instant dateTime = entity.getInstant(attrName);
      writeDateTime(generator, dateTime);
      break;
    case CATEGORICAL:
    case XREF:
    case FILE:
      Entity xrefEntity = entity.getEntity(attrName);
      writeReference(generator, depth, maxDepth, xrefEntity);
      break;
    case CATEGORICAL_MREF:
    case MREF:
    case ONE_TO_MANY:
      Iterable<Entity> mrefEntities = entity.getEntities(attrName);
      writeMultiReference(generator, depth, maxDepth, mrefEntities);
      break;
    case COMPOUND:
      throw new IllegalAttributeTypeException(attrType);
    default:
      throw new UnexpectedEnumException(attrType);
  }
}
 

@Override
public XContentGenerator createGenerator(Writer writer) throws IOException {
	return new CsvXContentGenerator(csvFactory.createGenerator(writer));
}
 

@Override
public XContentGenerator createGenerator(OutputStream os)
		throws IOException {
	 return new CsvXContentGenerator(csvFactory.createGenerator(os, JsonEncoding.UTF8));
}
 

public XContentGenerator generator() {
    return this.generator;
}
 

public static void copyCurrentEvent(XContentGenerator generator, XContentParser parser) throws IOException {
    switch (parser.currentToken()) {
        case START_OBJECT:
            generator.writeStartObject();
            break;
        case END_OBJECT:
            generator.writeEndObject();
            break;
        case START_ARRAY:
            generator.writeStartArray();
            break;
        case END_ARRAY:
            generator.writeEndArray();
            break;
        case FIELD_NAME:
            generator.writeFieldName(parser.currentName());
            break;
        case VALUE_STRING:
            if (parser.hasTextCharacters()) {
                generator.writeString(parser.textCharacters(), parser.textOffset(), parser.textLength());
            } else {
                generator.writeString(parser.text());
            }
            break;
        case VALUE_NUMBER:
            switch (parser.numberType()) {
                case INT:
                    generator.writeNumber(parser.intValue());
                    break;
                case LONG:
                    generator.writeNumber(parser.longValue());
                    break;
                case FLOAT:
                    generator.writeNumber(parser.floatValue());
                    break;
                case DOUBLE:
                    generator.writeNumber(parser.doubleValue());
                    break;
            }
            break;
        case VALUE_BOOLEAN:
            generator.writeBoolean(parser.booleanValue());
            break;
        case VALUE_NULL:
            generator.writeNull();
            break;
        case VALUE_EMBEDDED_OBJECT:
            generator.writeBinary(parser.binaryValue());
    }
}
 

@Override
public XContentGenerator createGenerator(OutputStream os, String[] filters) throws IOException {
    // ignore filters (for now)
    return new XmlXContentGenerator(xmlFactory.createGenerator(os, JsonEncoding.UTF8));
}