private static String buildTypeName(StructuredDataType targetType) { return "Reference<" + targetType.getName() + ">"; }
@Override public DocumentType clone() { DocumentType type = (DocumentType) super.clone(); type.headerType = headerType.clone(); type.bodyType = bodyType.clone(); type.inherits = new ArrayList<>(inherits.size()); for (DocumentType inherited : inherits) { type.inherits.add(inherited); } return type; }
private int compareTargetType(DataType rhs) { return (rhs instanceof ReferenceDataType) ? targetType.compareTo(((ReferenceDataType) rhs).targetType) : 0; }
@Override protected void register(DocumentTypeManager manager, List<DataType> seenTypes) { seenTypes.add(this); for (Field field : getFields()) { if (!seenTypes.contains(field.getDataType())) { //we haven't seen this one before, register it: field.getDataType().register(manager, seenTypes); } } super.register(manager, seenTypes); }
@Override public FieldPath buildFieldPath(String remainFieldName) { if (remainFieldName.length() == 0) { return new FieldPath(); } String currFieldName = remainFieldName; String subFieldName = ""; for (int i = 0; i < remainFieldName.length(); i++) { if (remainFieldName.charAt(i) == '.') { currFieldName = remainFieldName.substring(0, i); subFieldName = remainFieldName.substring(i + 1); break; } else if (remainFieldName.charAt(i) == '{' || remainFieldName.charAt(i) == '[') { currFieldName = remainFieldName.substring(0, i); subFieldName = remainFieldName.substring(i); break; } } Field f = getField(currFieldName); if (f != null) { FieldPath fieldPath = f.getDataType().buildFieldPath(subFieldName); List<FieldPathEntry> tmpPath = new ArrayList<FieldPathEntry>(fieldPath.getList()); tmpPath.add(0, FieldPathEntry.newStructFieldEntry(f)); return new FieldPath(tmpPath); } else { throw new IllegalArgumentException("Field '" + currFieldName + "' not found in type " + this); } }
private void replaceTemporaryTypeInReference(ReferenceDataType referenceDataType) { if (referenceDataType.getTargetType() instanceof TemporaryStructuredDataType) { referenceDataType.setTargetType((DocumentType) getDataType(referenceDataType.getTargetType().getId())); } // TODO should we recursively invoke replaceTemporaryTypes for the target type? It should only ever be a doc type }
@Override public boolean equals(Object rhs) { return super.equals(rhs) && (rhs instanceof ReferenceDataType) && targetType.equals(((ReferenceDataType) rhs).targetType); } }
public StructuredDataType(String name) { super(name, createId(name)); }
private FieldValue convertStructured(StructuredFieldValue val) { StructuredFieldValue ret = val.getDataType().createFieldValue(); for (Iterator<Map.Entry<Field, FieldValue>> it = val.iterator(); it.hasNext();) { Map.Entry<Field, FieldValue> entry = it.next(); FieldValue prev = entry.getValue(); FieldValue next = convert(prev); if (next == null) { continue; } ret.setFieldValue(entry.getKey(), next); } return ret; }
private void setCorrectAnnotationReference(StructuredFieldValue struct, IdentityHashMap<Annotation, Integer> originalAnnotations, List<Annotation> newAnnotations) { for (Field f : struct.getDataType().getFields()) { setCorrectAnnotationReference(struct.getFieldValue(f), originalAnnotations, newAnnotations); } }
public static boolean isComplete(Field field, ValueUpdate update) { if (update instanceof AssignValueUpdate) { return true; } if (!(update instanceof MapValueUpdate)) { return false; } DataType fieldType = field.getDataType(); if (!(fieldType instanceof StructuredDataType)) { return false; } field = ((StructuredDataType)fieldType).getField(String.valueOf(update.getValue())); if (field == null) { return false; } return isComplete(field, ((MapValueUpdate)update).getUpdate()); }
private void buildConfig(ReferenceDataType type, DocumenttypesConfig.Documenttype.Builder documentBuilder) { ReferenceDataType refType = type; DocumenttypesConfig.Documenttype.Referencetype.Builder refBuilder = new DocumenttypesConfig.Documenttype.Referencetype.Builder(); refBuilder.id(refType.getId()); refBuilder.target_type_id(type.getTargetType().getId()); documentBuilder.referencetype(refBuilder); }
public boolean equals(Object o) { if (!(o instanceof DocumentType)) return false; DocumentType other = (DocumentType) o; // Ignore whether one of them have added inheritance to super Document.0 type if (super.equals(o) && headerType.equals(other.headerType) && bodyType.equals(other.bodyType)) { if ((inherits.size() > 1 || other.inherits.size() > 1) || (inherits.size() == 1 && other.inherits.size() == 1)) { return inherits.equals(other.inherits); } return !(((inherits.size() == 1) && !inherits.get(0).getDataTypeName().equals(new DataTypeName("document"))) || ((other.inherits.size() == 1) && !other.inherits.get(0).getDataTypeName().equals(new DataTypeName("document")))); } return false; }
/** * Returns the name of this as a DataTypeName * * @return Return the Documentname of this doumenttype. */ public DataTypeName getDataTypeName() { return new DataTypeName(getName()); }
private boolean removeObsoleteReferencesFromStructuredType(StructuredFieldValue struct, Map<Annotation, Annotation> selectedAnnotations, boolean removeIfPresent) { for (Field f : struct.getDataType().getFields()) { FieldValue fValue = struct.getFieldValue(f); if (removeObsoleteReferencesFromFieldValue(fValue, selectedAnnotations, removeIfPresent)) { struct.removeFieldValue(f); } } return false; }
@Override protected void checkCompatibility(DataType fieldType) { if (fieldType instanceof ArrayDataType) { if (!(value instanceof IntegerFieldValue)) { throw new IllegalArgumentException("Expected integer, got " + value.getClass().getName() + "."); } update.checkCompatibility(((ArrayDataType)fieldType).getNestedType()); } else if (fieldType instanceof WeightedSetDataType) { ((WeightedSetDataType)fieldType).getNestedType().createFieldValue().assign(value); update.checkCompatibility(DataType.INT); } else if (fieldType instanceof StructuredDataType) { if (!(value instanceof StringFieldValue)) { throw new IllegalArgumentException("Expected string, got " + value.getClass().getName() + "."); } Field field = ((StructuredDataType)fieldType).getField(((StringFieldValue)value).getString()); if (field == null) { throw new IllegalArgumentException("Field '" + value + "' not found."); } update.checkCompatibility(field.getDataType()); } else { throw new UnsupportedOperationException("Field type " + fieldType.getName() + " not supported."); } }
builder.referencetype(new Datatype.Referencetype.Builder().target_type_id(refType.getTargetType().getId())); } else { throw new IllegalArgumentException("Can not create config for data type '" + type.getName());
@Override public BaseStructDataType clone() { BaseStructDataType type = (BaseStructDataType) super.clone(); type.fieldIds = new LinkedHashMap<>(); type.fieldIdsV6 = new LinkedHashMap<>(); type.fields = new LinkedHashMap<>(); for (Field field : fieldIds.values()) { type.fields.put(field.getName(), field); type.fieldIds.put(field.getId(Document.SERIALIZED_VERSION), field); type.fieldIdsV6.put(field.getId(6), field); } return type; }
private static String getTargetDocumentName(ReferenceDataType reference) { return reference.getTargetType().getName(); }
@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()); }