@Override protected ValueObject convert(ValueObject nextValue) { if (nextValue.getObjectType() != ValueObject.TYPE.ARRAY) { return nextValue.asString(); } else { return nextValue; } }
@Override public boolean filter(Bundle bundle) { ValueObject lv = left.getValue(bundle); ValueObject rv = right.getValue(bundle); if (lv == null && rv == null) { return !not; } else if (lv == null || rv == null) { return not; } ValueObject.TYPE lt = lv.getObjectType(); ValueObject.TYPE rt = lv.getObjectType(); if (lt != rt) { return not; } else if (lv.equals(rv)) { return !not; } else { return not; } }
@VisibleForTesting static void buildValue(StringBuilder builder, ValueObject value) { ValueObject.TYPE type = value.getObjectType(); if (type == ValueObject.TYPE.CUSTOM) { value = value.asCustom().asSimple(); type = value.getObjectType(); } switch (type) { case INT: case FLOAT: builder.append(value.toString()); break; case STRING: builder.append("\""); builder.append(quoteString(value.toString())); builder.append("\""); break; default: break; } }
@Override public ValueObject filterValue(ValueObject value) { if (value != null) { ValueMap map = ValueFactory.createMap(); if (value.getObjectType() == ValueObject.TYPE.ARRAY) { for (ValueObject vo : ((ValueArray) value)) { // expect ValueString here if (vo.getObjectType() == ValueObject.TYPE.STRING) { insertMapValue(map, vo); } } } else { insertMapValue(map, value); } return map; } return null; }
/** * Helper method for {@link #filter(ValueObject)} and {@link AbstractValueFilterContextual#filter(ValueObject, Bundle)} * that determines if array handling is necessary. * * @param value input value * @param context optional bundle context * @return output value */ @Nullable protected final ValueObject filterWithArrayHandling(@Nullable ValueObject value, @Nullable Bundle context) { if (once) { return filterValue(value, context); } // TODO why is this behaviour not there for TYPE.MAPS ? if ((value != null) && (value.getObjectType() == ValueObject.TYPE.ARRAY)) { return filterArray(value, context); } return filterValue(value, context); }
@Override public ValueObject filterValue(ValueObject value) { if (value == null) { return null; } ValueObject.TYPE type = value.getObjectType(); switch (type) { case ARRAY: return sortArray(value.asArray()); case INT: return value; case FLOAT: return value; case STRING: return value; default: throw new RuntimeException("Unsupported object type " + type); } }
private void announce(String metricName, String metricGroup, ValueObject metricValue, String metricUnits) throws GangliaException { // see if we have to represent a long as a double if (metricValue.getObjectType() == ValueObject.TYPE.INT) { long asLong = metricValue.asLong().getLong(); if ((int) asLong != asLong) { metricValue = metricValue.asDouble(); } } for (GMetric gmetric : gmetrics) { gmetric.announce(metricName, metricValue.toString(), detectType(metricValue.getObjectType()), metricUnits, GMetricSlope.BOTH, tMax, dMax, metricGroup); } }
@Override public ValueObject filterValue(ValueObject value) { if (value == null) { return null; } if (value.getObjectType() == ValueObject.TYPE.ARRAY) { ValueArray arr = value.asArray(); int size = arr.size(); int half = size / 2; for (int i = 0; i < half; i++) { int altpos = size - i - 1; ValueObject tmp = arr.get(i); arr.set(i, arr.get(altpos)); arr.set(altpos, tmp); } return arr; } else if (value.getObjectType() == ValueObject.TYPE.STRING) { return ValueFactory.create(new StringBuilder(value.toString()).reverse().toString()); } return value; }
@Override public ValueObject filterValue(ValueObject value) { if (value != null) { if (value.getObjectType() == ValueObject.TYPE.ARRAY) { return ValueFactory.create(value.asArray().size()); } if (value.getObjectType() == ValueObject.TYPE.MAP) { return ValueFactory.create(value.asMap().size()); } Numeric num = ValueUtil.asNumber(value); if (num != null) { return num; } return ValueFactory.create(ValueUtil.asNativeString(value).length()); } return null; }
private Object unbox(ValueObject val) { switch (val.getObjectType()) { case INT: return val.asLong().getLong(); case FLOAT: return val.asDouble().getDouble(); case STRING: return val.asString().asNative(); case ARRAY: List<Object> retList = new LinkedList<>(); for (ValueObject element : val.asArray()) { retList.add(unbox(element)); } return retList; case MAP: Map<String, Object> retMap = new HashMap<>(); ValueMap valAsMap = val.asMap(); for (ValueMapEntry entry : valAsMap) { retMap.put(entry.getKey(), unbox(entry.getValue())); } return retMap; } throw new IllegalArgumentException("Unsupported bundle field type: " + val.getObjectType()); }
private void test(ValueFilterPrettyPrint vf, ValueObject input, Set<String> output) { ValueObject result1 = vf.filter(input); ValueObject result2 = vf.filterValue(input); assertNotNull(result1); assertNotNull(result2); assertEquals(ValueObject.TYPE.STRING, result1.getObjectType()); assertEquals(ValueObject.TYPE.STRING, result2.getObjectType()); assertTrue("result is " + result1.toString(), output.contains(result1.toString())); assertTrue("result is " + result2.toString(), output.contains(result2.toString())); }
@VisibleForTesting boolean updateChildData(Bundle bundle, Config conf) { ValueObject valueObject = conf.key.getValue(bundle); if (valueObject == null) { return false; } if (valueObject.getObjectType() == ValueObject.TYPE.ARRAY) { ValueArray array = valueObject.asArray(); Iterator<ValueObject> iterator = array.iterator(); boolean updated = false; while (iterator.hasNext()) { ValueObject next = iterator.next(); updated = updated | updateString(next.asString().asNative(), iterator, bundle, conf); } return updated; } else { return updateString(valueObject.asString().asNative(), null, bundle, conf); } }
@Override public ValueObject filterValue(ValueObject value, Bundle context) { if (value == null || value.getObjectType() != ValueObject.TYPE.MAP || this.key == null) { // TODO: log error return null; } ValueMap mapValue = value.asMap(); if (this.put != null) { ValueMap copy = ValueFactory.createMap(); copy.putAll(mapValue); copy.put(this.key.getString(context).get(), this.put.getValue(context)); return copy; } else if (this.defaultValue != null) { return mapValue.getOrDefault(this.key.getString(context).get(), this.defaultValue.getValue(context)); } else { return mapValue.get(this.key.getString(context).get()); } } }
@Override public ValueObject filter(ValueObject value, Bundle context) { ValueObject nullReturn = toNull ? null : value; if (ValueUtil.isEmpty(value)) { return nullReturn; } if (value.getObjectType() == ValueObject.TYPE.ARRAY) { ValueArray arr = value.asArray(); if (arr.isEmpty()) { return nullReturn; } int i = index.getInt(context).getAsInt(); while (i < 0) { i = arr.size() + i; } return (arr.size() > i) ? arr.get(i) : nullReturn; } return nullReturn; }
private synchronized boolean updateSketch(Bundle row, String key, ValueObject valueObject) { CountMinSketch sketch = sketches.get(key); if (valueObject == null) { return failReturn; } if (valueObject.getObjectType() == ValueObject.TYPE.ARRAY) { ValueArray array = valueObject.asArray(); Iterator<ValueObject> iterator = array.iterator(); while (iterator.hasNext()) { ValueObject next = iterator.next(); updateString(next.asString().asNative(), sketch, iterator, row); } return true; } else { return updateString(valueObject.asString().asNative(), sketch, null, row); } }
@Override public ValueObject filter(ValueObject value, Bundle context) { if (value != null && value.getObjectType() == ValueObject.TYPE.ARRAY) { ValueArray in = value.asArray(); ValueArray out = null; for (ValueObject vo : in) { ValueObject val = this.elementFilter.filter(vo, context); if (val != null) { if (out == null) { out = ValueFactory.createArray(in.size()); } out.add(val); } } return out; } return null; }
private void test(ValueFilterPrettyPrint vf, ValueObject input, String output) { ValueObject result1 = vf.filter(input); ValueObject result2 = vf.filterValue(input); assertNotNull(result1); assertNotNull(result2); assertEquals(ValueObject.TYPE.STRING, result1.getObjectType()); assertEquals(ValueObject.TYPE.STRING, result2.getObjectType()); assertEquals(output, result1.toString()); assertEquals(output, result2.toString()); }
@Override public boolean updateChildData(DataTreeNodeUpdater state, DataTreeNode childNode, Config conf) { if (key == null) { key = conf.key; filter = conf.filter; } ValueObject val = key.getValue(state.getBundle()); if (val != null) { if (filter != null) { val = filter.filter(val, state.getBundle()); if (val == null) { return false; } } if (val.getObjectType() == ValueObject.TYPE.ARRAY) { for (ValueObject obj : val.asArray()) { update(obj); } } else { update(val); } } return true; }
@Override public void process(Bundle bundle, StreamEmitter emitter) { ValueObject obj = field.getValue(bundle); field.removeValue(bundle); if ((obj != null) && (obj.getObjectType() == ValueObject.TYPE.MAP)) { ValueMap map = obj.asMap(); for (ValueMapEntry entry : map) { Bundle newBundle = Bundles.deepCopyBundle(bundle); keyField.setValue(newBundle, ValueFactory.create(entry.getKey())); valueField.setValue(newBundle, entry.getValue()); if (emitFilter == null || emitFilter.filter(newBundle)) { emitter.emit(newBundle); } } } if (emitOriginal && (emitFilter == null || emitFilter.filter(bundle))) { emitter.emit(bundle); } } }
@Override public void process(Bundle row, StreamEmitter emitter) { BundleField fieldFrom = row.getFormat().getField(fromArrayField); BundleField fieldTo = row.getFormat().getField(toField); ValueObject fromObject = row.getValue(fieldFrom); if (fromObject == null || fromObject.getObjectType() != ValueObject.TYPE.ARRAY) { if (emitFilter == null || emitFilter.filter(row)) { emitter.emit(row); } } else { ValueArray fromArray = fromObject.asArray(); for (ValueObject element : fromArray) { Bundle newBundle = row.createBundle(); for (BundleField field : row.getFormat()) { newBundle.setValue(field, row.getValue(field)); } newBundle.setValue(fieldTo, element); if (emitFilter == null || emitFilter.filter(newBundle)) { emitter.emit(newBundle); } } } } }