public Array(DataType type, List<T> values) { this(type); for (T v : values) { if (!((ArrayDataType)type).getNestedType().isValueCompatible(v)) { throw new IllegalArgumentException("FieldValue " + v + " is not compatible with " + type + "."); } } this.values.addAll(values); }
/** * Returns an array datatype, where the array elements are of the given type * * @param type the type to create an array of * @return the array data type */ public static ArrayDataType getArray(DataType type) { return new ArrayDataType(type); }
@SuppressWarnings({ "unchecked", "rawtypes" }) private static FieldValue asArray(ArrayDataType arrType, List<FieldValue> values) { Array out = arrType.createFieldValue(); for (FieldValue val : values) { if (val == null) { continue; } out.addAll((Array)val); } return out; }
@Override public FieldPath buildFieldPath(String remainFieldName) { if (remainFieldName.length() > 0 && remainFieldName.charAt(0) == '[') { int endPos = remainFieldName.indexOf(']'); if (endPos == -1) { throw new IllegalArgumentException("Array subscript must be closed with ]"); } else { FieldPath path = getNestedType().buildFieldPath(skipDotInString(remainFieldName, endPos)); List<FieldPathEntry> tmpPath = new ArrayList<FieldPathEntry>(path.getList()); if (remainFieldName.charAt(1) == '$') { tmpPath.add(0, FieldPathEntry.newVariableLookupEntry(remainFieldName.substring(2, endPos), getNestedType())); } else { tmpPath.add(0, FieldPathEntry.newArrayLookupEntry(Integer.parseInt(remainFieldName.substring(1, endPos)), getNestedType())); } return new FieldPath(tmpPath); } } return getNestedType().buildFieldPath(remainFieldName); }
private static boolean isArrayOfStructType(DataType type) { if (type instanceof ArrayDataType) { ArrayDataType arrayType = (ArrayDataType)type; return isStructType(arrayType.getNestedType()); } else { return false; } }
private static void registerArrayType(DocumentTypeManager manager, int id, DocumentmanagerConfig.Datatype.Arraytype array) { DataType nestedType = manager.getDataType(array.datatype(), ""); ArrayDataType type = new ArrayDataType(nestedType, id); manager.register(type); }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override protected void doExecute(ExecutionContext ctx) { FieldValue input = ctx.getValue(); DataType inputType = input.getDataType(); ArrayDataType outputType = DataType.getArray(inputType); Array output = outputType.createFieldValue(); output.add(input); ctx.setValue(output); }
private static boolean isSupportedPositionType(DataType dataType) { if (dataType instanceof ArrayDataType) { dataType = ((ArrayDataType)dataType).getNestedType(); } return dataType.equals(PositionDataType.INSTANCE); }
@Override public void onPrimitive(FieldValue fv) { if (retVal != null) { if (multiValue) { ((Array) retVal).add(fv); } else { Array afv = new Array(new ArrayDataType(retVal.getDataType())); afv.add(retVal); afv.add(fv); retVal = afv; multiValue = true; } } else { retVal = fv; } } }
@SuppressWarnings({ "unchecked", "rawtypes" }) private FieldValue convertArray(Array val) { List<FieldValue> next = new LinkedList<FieldValue>(); DataType nextType = null; for (Iterator<FieldValue> it = val.fieldValueIterator(); it.hasNext();) { FieldValue prevVal = it.next(); FieldValue nextVal = convert(prevVal); if (nextVal == null) { continue; } if (nextType == null) { nextType = nextVal.getDataType(); } else if (!nextType.isValueCompatible(nextVal)) { throw new IllegalArgumentException("Expected " + nextType.getName() + ", got " + nextVal.getDataType().getName() + "."); } next.add(nextVal); } if (nextType == null) { return null; } Array ret = DataType.getArray(nextType).createFieldValue(); for (FieldValue nextVal : next) { ret.add(nextVal); } return ret; }
public static boolean isArrayOfSimpleStruct(ImmutableSDField field) { if (field.getDataType() instanceof ArrayDataType) { ArrayDataType arrayType = (ArrayDataType)field.getDataType(); return isStructWithPrimitiveStructFieldAttributes(arrayType.getNestedType(), field); } else { return false; } }
private void processField(Search search, SDField uriField) { String uriName = uriField.getName(); uriField.setStemming(Stemming.NONE); DataType generatedType = DataType.STRING; if (uriField.getDataType() instanceof ArrayDataType) { generatedType = new ArrayDataType(DataType.STRING); } else if (uriField.getDataType() instanceof WeightedSetDataType) { WeightedSetDataType wdt = (WeightedSetDataType) uriField.getDataType(); generatedType = new WeightedSetDataType(DataType.STRING, wdt.createIfNonExistent(), wdt.removeIfZero()); } for (String suffix : URL_SUFFIX) { String partName = uriName + "." + suffix; // I wonder if this is explicit in qrs or implicit in backend? // search.addFieldSetItem(uriName, partName); SDField partField = new SDField(partName, generatedType, true); partField.setIndexStructureField(uriField.doesIndexing()); partField.setRankType(uriField.getRankType()); partField.setStemming(Stemming.NONE); partField.getNormalizing().inferLowercase(); if (uriField.getIndex(suffix) != null) { partField.addIndex(uriField.getIndex(suffix)); } search.addExtraField(partField); search.fieldSets().addBuiltInFieldSetItem(BuiltInFieldSets.INTERNAL_FIELDSET_NAME, partField.getName()); } }
public <T extends FieldValue> void read(FieldBase field, Array<T> value) { try { while (reader.hasNext()) { int type = reader.next(); if (type == XMLStreamReader.START_ELEMENT) { if ("item".equals(reader.getName().toString())) { FieldValue fv = (value.getDataType()).getNestedType().createFieldValue(); deserializeFieldValue(field, fv); // noinspection unchecked value.add((T)fv); skipToEnd("item"); } } else if (type == XMLStreamReader.END_ELEMENT) { return; } } } catch (XMLStreamException e) { throw newException(field, e); } }
@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."); } }
static void validate(DocumentTypeManager manager, String documentTypeName, String arrayFieldName) { DocumentType docType = manager.getDocumentType(documentTypeName); if (docType == null) { //the document type does not exist, return throw new IllegalStateException("The document type " + documentTypeName + " is not deployed."); } if (docType.getField(arrayFieldName) == null) { //the document type does not have the field, return throw new IllegalStateException("The document type " + documentTypeName + " does not have a field named " + arrayFieldName + "."); } if (!(docType.getField(arrayFieldName).getDataType() instanceof ArrayDataType)) { //the data type of the field is wrong, return throw new IllegalStateException("The data type of the field named " + arrayFieldName + " in document type " + documentTypeName + " is not an array type"); } ArrayDataType fieldDataType = (ArrayDataType) docType.getField(arrayFieldName).getDataType(); if (!(fieldDataType.getNestedType() instanceof DocumentType)) { //the subtype of tye array data type of the field is wrong, return throw new IllegalStateException("The data type of the field named " + arrayFieldName + " in document type " + documentTypeName + " is not an array of Document."); } }
private void buildConfig(ArrayDataType type, DocumenttypesConfig.Documenttype.Datatype.Builder dataTypeBuilder, DocumenttypesConfig.Documenttype.Builder documentBuilder, Set<Integer> built) { dataTypeBuilder. type(DocumenttypesConfig.Documenttype.Datatype.Type.Enum.ARRAY). array(new DocumenttypesConfig.Documenttype.Datatype.Array.Builder(). element(new DocumenttypesConfig.Documenttype.Datatype.Array.Element.Builder().id(type.getNestedType().getId()))); buildConfig(type.getNestedType(), documentBuilder, built); }
public boolean hasFieldForStructFieldAttribute(Attribute structFieldAttribute) { StringTokenizer fieldNames = new StringTokenizer(structFieldAttribute.getName(), "."); if (!fieldNames.nextToken().equals(field.getName())) { return false; } if (isArrayOfStructType(dataType())) { StructDataType nestedType = (StructDataType)((ArrayDataType)dataType()).getNestedType(); if (structTypeContainsLastFieldNameComponent(nestedType, fieldNames)) { return true; } } else if (isMapOfStructType(dataType())) { MapDataType mapType = (MapDataType)dataType(); StructDataType valueType = (StructDataType)mapType.getValueType(); String subFieldName = fieldNames.nextToken(); if (subFieldName.equals("key") && !fieldNames.hasMoreTokens()) { return true; } else if (subFieldName.equals("value") && structTypeContainsLastFieldNameComponent(valueType, fieldNames)) { return true; } } else if (isMapOfPrimitiveType(dataType())) { String subFieldName = fieldNames.nextToken(); if ((subFieldName.equals("key") || subFieldName.equals("value")) && !fieldNames.hasMoreTokens()) { return true; } } return false; }
public <T extends FieldValue> void read(FieldBase field, Array<T> array) { int numElements = getNumCollectionElems(); ArrayList<T> list = new ArrayList<T>(numElements); ArrayDataType type = array.getDataType(); for (int i = 0; i < numElements; i++) { if (version < 7) { getInt(null); // We don't need size for anything } FieldValue fv = type.getNestedType().createFieldValue(); fv.deserialize(null, this); list.add((T) fv); } array.clear(); array.addAll(list); }
public <T extends FieldValue> void read(FieldBase field, Array<T> array) { int numElements = getNumCollectionElems(); ArrayList<T> list = new ArrayList<T>(numElements); ArrayDataType type = array.getDataType(); for (int i = 0; i < numElements; i++) { if (version < 7) { getInt(null); // We don't need size for anything } FieldValue fv = type.getNestedType().createFieldValue(); fv.deserialize(null, this); list.add((T) fv); } array.clear(); array.addAll(list); }