@SuppressWarnings({ "unchecked", "rawtypes" }) private FieldValue convertWset(WeightedSet val) { Map<FieldValue, Integer> next = new LinkedHashMap<FieldValue, Integer>(); DataType nextType = null; for (Iterator<FieldValue> it = val.fieldValueIterator(); it.hasNext();) { FieldValue prevKey = it.next(); Integer prevVal = val.get(prevKey); FieldValue nextKey = convert(prevKey); if (nextKey == null) { continue; } if (nextType == null) { nextType = nextKey.getDataType(); } else if (!nextType.isValueCompatible(nextKey)) { throw new IllegalArgumentException("Expected " + nextType.getName() + ", got " + nextKey.getDataType().getName() + "."); } next.put(nextKey, prevVal); } if (nextType == null) { return null; } WeightedSet ret = DataType.getWeightedSet(nextType, val.getDataType().createIfNonExistent(), val.getDataType().removeIfZero()).createFieldValue(); for (Map.Entry<FieldValue, Integer> entry : next.entrySet()) { ret.put(entry.getKey(), entry.getValue()); } return ret; }
/** Creates an attribute with default settings */ public Attribute(String name, DataType fieldType) { this(name, convertDataType(fieldType), convertCollectionType(fieldType), convertTensorType(fieldType), convertTargetType(fieldType)); setRemoveIfZero(fieldType instanceof WeightedSetDataType ? ((WeightedSetDataType)fieldType).removeIfZero() : false); setCreateIfNonExistent(fieldType instanceof WeightedSetDataType ? ((WeightedSetDataType)fieldType).createIfNonExistent() : false); }
public void apply(SDField field) { WeightedSetDataType ctype = (WeightedSetDataType) field.getDataType(); if (createIfNonExistent != null) { field.setDataType(DataType.getWeightedSet(ctype.getNestedType(), createIfNonExistent, ctype.removeIfZero())); } ctype = (WeightedSetDataType) field.getDataType(); if (removeIfZero != null) { field.setDataType(DataType.getWeightedSet(ctype.getNestedType(), ctype.createIfNonExistent(), removeIfZero)); } ctype = (WeightedSetDataType) field.getDataType(); for (Object o : field.getAttributes().values()) { Attribute attribute = (Attribute) o; attribute.setRemoveIfZero(ctype.removeIfZero()); attribute.setCreateIfNonExistent(ctype.createIfNonExistent()); } }
private void buildConfig(WeightedSetDataType type, DocumenttypesConfig.Documenttype.Datatype.Builder dataTypeBuilder, DocumenttypesConfig.Documenttype.Builder documentBuilder, Set<Integer> built) { dataTypeBuilder.type(DocumenttypesConfig.Documenttype.Datatype.Type.Enum.WSET). wset(new DocumenttypesConfig.Documenttype.Datatype.Wset.Builder(). key(new DocumenttypesConfig.Documenttype.Datatype.Wset.Key.Builder(). id(type.getNestedType().getId())). createifnonexistent(type.createIfNonExistent()). removeifzero(type.removeIfZero())); buildConfig(type.getNestedType(), documentBuilder, built); }
@Override public FieldValue applyTo(FieldValue fval) { if (fval instanceof Array) { Array array = (Array) fval; FieldValue element = array.getFieldValue(((IntegerFieldValue) value).getInteger()); element = update.applyTo(element); array.set(((IntegerFieldValue) value).getInteger(), element); } else if (fval instanceof WeightedSet) { WeightedSet wset = (WeightedSet) fval; WeightedSetDataType wtype = wset.getDataType(); Integer weight = wset.get(value); if (weight == null) { if (wtype.createIfNonExistent() && update instanceof ArithmeticValueUpdate) { weight = 0; } else { return fval; } } weight = (Integer) update.applyTo(new IntegerFieldValue(weight)).getWrappedValue(); wset.put(value, weight); if (wtype.removeIfZero() && update instanceof ArithmeticValueUpdate && weight == 0) { wset.remove(value); } } return fval; }
@Override protected void doVerify(VerificationContext context) { DataType input = context.getValue(); if (input instanceof ArrayDataType || input instanceof WeightedSetDataType) { context.setValue(((CollectionDataType)input).getNestedType()).execute(exp); if (input instanceof ArrayDataType) { context.setValue(DataType.getArray(context.getValue())); } else { WeightedSetDataType wset = (WeightedSetDataType)input; context.setValue(DataType.getWeightedSet(context.getValue(), wset.createIfNonExistent(), wset.removeIfZero())); } } else if (input instanceof StructDataType) { for (Field field : ((StructDataType)input).getFields()) { DataType fieldType = field.getDataType(); DataType valueType = context.setValue(fieldType).execute(exp).getValue(); if (!fieldType.isAssignableFrom(valueType)) { throw new VerificationException(this, "Expected " + fieldType.getName() + " output, got " + valueType.getName() + "."); } } context.setValue(input); } else { throw new VerificationException(this, "Expected Array, Struct or WeightedSet input, got " + input.getName() + "."); } }
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()); } }
datatype(dt.getNestedType().getId()). createifnonexistant(dt.createIfNonExistent()). removeifzero(dt.removeIfZero())); } else if (type instanceof MapDataType) { MapDataType mtype = (MapDataType) type;