/** * Adds a new header field to this document type and returns the new field object * * @param name The name of the field to add * @param type The datatype of the field to add * @return The field created * TODO Fix searchdefinition so that exception can be thrown if filed is already registerd */ public Field addHeaderField(String name, DataType type) { if (isRegistered()) { throw new IllegalStateException("You cannot add fields to a document type that is already registered."); } Field field = new Field(name, type, true); headerType.addField(field); return field; }
/** * Adds a new body field to this document type and returns the new field object * * @param name The name of the field to add * @param type The datatype of the field to add * @return The field created * TODO Fix searchdefinition so that exception can be thrown if filed is already registerd. */ public Field addField(String name, DataType type) { if (isRegistered()) { throw new IllegalStateException("You cannot add fields to a document type that is already registered."); } Field field = new Field(name, type, false); bodyType.addField(field); return field; }
private FieldPath getFieldPath(String fieldName) { if (fieldMap != null && fieldMap.containsKey(fieldName)) { fieldName = fieldMap.get(fieldName); } checkAccess(new Field(fieldName)); FieldPath path = FieldPath.newInstance(getDataType(), fieldName); if (path == null || path.size() == 0) { throw new IllegalArgumentException("Malformed schema mapping '" + fieldName + "'."); } return path; }
/** * Returns a field representation of the imported field. * Changes to the returned instance are not propagated back to the underlying imported field! */ @Override public Field asField() { return new Field( importedField.fieldName(), importedField.targetField().getDataType()); }
private static Field resolveField(FieldPathUpdate update) { String orig = update.getOriginalFieldPath(); if (orig == null) { return null; } FieldPath path = update.getFieldPath(); if (path == null) { return null; } DataType type = path.getResultingDataType(); if (type == null) { return null; } return new Field(orig, type); } }
@Override public void write(Document document) { buffer = new XmlStream(); buffer.setIndent(indent); optionalWrapperMarker.clear(); write(new Field(document.getDataType().getName(), 0, document.getDataType(), true), document); }
@SuppressWarnings("deprecation") static List<Field> flattenField(Field field) { DataType fieldType = field.getDataType(); if (fieldType.getPrimitiveType() != null){ return Collections.singletonList(field); } if (fieldType instanceof ArrayDataType) { boolean header = field.isHeader(); List<Field> ret = new LinkedList<>(); Field innerField = new Field(field.getName(), ((ArrayDataType)fieldType).getNestedType(), header); for (Field flatField : flattenField(innerField)) { ret.add(new Field(flatField.getName(), DataType.getArray(flatField.getDataType()), header)); } return ret; } if (fieldType instanceof StructuredDataType) { List<Field> ret = new LinkedList<>(); String fieldName = field.getName(); for (Field childField : ((StructuredDataType)fieldType).getFields()) { for (Field flatField : flattenField(childField)) { ret.add(new Field(fieldName + "." + flatField.getName(), flatField)); } } return ret; } throw new UnsupportedOperationException(fieldType.getName()); }
public void write(Document doc) { write(new Field(doc.getDataType().getName(), 0, doc.getDataType(), true), doc); }
public void write(Document doc) { write(new Field(doc.getDataType().getName(), 0, doc.getDataType(), true), doc); }
public void addToModel(Search search) { // Then we add the search specific stuff SearchDef searchDef = new SearchDef(search.getName()); addSearchFields(search.extraFieldList(), searchDef); for (Field f : search.getDocument().fieldSet()) { addSearchField((SDField) f, searchDef); } for (SDField field : search.allConcreteFields()) { for (Attribute attribute : field.getAttributes().values()) { if ( ! searchDef.getFields().containsKey(attribute.getName())) { searchDef.add(new SearchField(new Field(attribute.getName(), field), !field.getIndices().isEmpty(), true)); } } } for (Field f : search.getDocument().fieldSet()) { addAlias((SDField) f, searchDef); } model.getSearchManager().add(searchDef); }
private static void registerStructType(DocumentmanagerConfig config, DocumentTypeManager manager, int id, DocumentmanagerConfig.Datatype.Structtype struct) { StructDataType type = new StructDataType(id, struct.name()); if (config.enablecompression()) { CompressionConfig comp = makeCompressionConfig(struct); type.setCompressionConfig(comp); } for (Object j : struct.field()) { DocumentmanagerConfig.Datatype.Structtype.Field field = (DocumentmanagerConfig.Datatype.Structtype.Field) j; DataType fieldType = (field.datatype() == id) ? manager.getDataTypeAndReturnTemporary(field.datatype(), field.detailedtype()) : manager.getDataType(field.datatype(), field.detailedtype()); if (field.id().size() == 1) { type.addField(new Field(field.name(), field.id().get(0).id(), fieldType, true)); } else { type.addField(new Field(field.name(), fieldType, true)); } } manager.register(type); }