@Override public Entry<String, List<String>> next() { Entry<String, ValueObject> input = iterator.next(); return new SimpleEntry<>(input.getKey(), new ListString(input.getValue().asArray(), false)); }
@Override public List<String> remove(Object key) { String stringKey = (String) key; ValueObject val = data.remove(stringKey); if (val == null) { return null; } else { return new ListString(val.asArray(), false); } }
@Override public List<String> get(Object key) { String stringKey = (String) key; ValueObject val = data.get(stringKey); if (val == null) { return null; } else { return new ListString(val.asArray(), false); } }
@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); } }
@Override public List<String> put(String key, List<String> value) { ValueObject val = data.put(key, ListString.create(value)); if (val == null) { return null; } else { return new ListString(val.asArray(), false); } }
/** * Iterate over the input value and apply the filter to each element of the array. * * @param value input array * @param context Optional context for this filter. * @return output array */ @Nullable private ValueObject filterArray(ValueObject value, Bundle context) { ValueArray in = value.asArray(); ValueArray out = null; for (ValueObject vo : in) { ValueObject val = filterValue(vo, context); if (val != null) { if (out == null) { out = ValueFactory.createArray(in.size()); } out.add(val); } } return out; }
@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; }
@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 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; }
@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; }
@Test public void akamaiGroup() { ValueFilterRegex vf = new ValueFilterRegex().setPattern(Pattern.compile("Log_([0-9]+)\\.")); ValueObject res = vf.filter(ValueFactory.create("stream://san1.local:8614/split/logs/12345/2011/05/20/aLog_12345.esw3c_U.201105200000-0100-1.gz")); assertTrue(res != null); assertTrue(res.asArray().size() > 0); assertEquals("12345", res.asArray().get(0).asString().toString()); } }
public MapStringListString(ValueMap map, boolean copy) { if (copy) { this.data = ValueFactory.createMap(); for (ValueMapEntry entry : map) { ValueArray array = entry.getValue().asArray(); int size = array.size(); ValueArray copyArray = ValueFactory.createArray(size); for (int i = 0; i < size; i++) { copyArray.add(array.get(i)); } this.data.put(entry.getKey(), copyArray); } } else { this.data = map; } }
private void verifyOnePass() { bundle = source.next(); assertNotNull(bundle); assertEquals("a", getField("A").asString().asNative()); assertEquals(new Long(1), getField("B").asLong().asNative()); assertNotNull(bundle); bundle = source.next(); assertNotNull(bundle); assertEquals(Lists.newArrayList(new Long(1), new Long(2)), getField("C").asArray().asNative()); assertEquals(Lists.newArrayList("a", "b"), getField("D").asArray().asNative()); }
@Override public void setValues(ValueMap map) { targetEpoch = map.get("targetEpoch").asLong().asNative(); numObservations = map.get("numObservations").asLong().asNative().intValue(); doubleToLongBits = map.get("doubleToLongBits").asLong().asNative().intValue() == 1; raw = map.get("raw").asLong().asNative().intValue() == 1; percentile = map.get("percentile").asDouble().asNative(); sigma = map.get("sigma").asDouble().asNative(); minMeasurement = map.get("minMeasurement").asLong().asNative().intValue(); mode = map.get("mode").asString().asNative(); long minEpoch = map.get("minEpoch").asLong().asNative(); ValueArray reservoirValueObject = map.get("reservoir").asArray(); int size = reservoirValueObject.size(); int[] reservoir = new int[size]; for (int i = 0; i < size; i++) { reservoir[i] = reservoirValueObject.get(i).asLong().asNative().intValue(); } this.heldObject = new DataReservoir(minEpoch, reservoir); }
@Test public void contextualIndex() throws IOException { ValueFilter valueFilter = decodeObject(ValueFilterIndex.class, "index.field = idx"); Bundle bundle = Bundles.decode("idx = 2"); ValueArray arr = ValueFactory.decodeValue("[a, b, c, d]").asArray(); assertEquals(valueFilter.filter(arr, bundle), arr.get(2)); }
@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); } } } } }
@Test public void append() throws IOException { ValueFilterCreateMap vf = Configs.decodeObject(ValueFilterCreateMap.class, "appendValues=true"); ValueMap result = vf.filter(ValueFactory.create("hello=world,baz=quux,hello=bar,hello=world")).asMap(); ValueArray values = result.get("hello").asArray(); assertEquals(3, values.size()); assertEquals("world", values.get(0).asString().asNative()); assertEquals("bar", values.get(1).asString().asNative()); assertEquals("world", values.get(2).asString().asNative()); assertEquals("quux", result.get("baz").asString().asNative()); }
@Test public void testGetValue() { DataReservoir reservoir = new DataReservoir(); reservoir.updateReservoir(1, 4, 4); reservoir.updateReservoir(2, 4, 12); reservoir.updateReservoir(3, 4, 4); reservoir.updateReservoir(4, 4, 100); ValueArray result = reservoir.getValue("epoch||4~sigma||2.0~obs||3").asArray(); assertEquals(5, result.size()); assertEquals(86, DoubleMath.roundToLong(result.get(0).asDouble().getDouble(), RoundingMode.HALF_UP)); assertEquals(100, result.get(1).asLong().getLong()); assertEquals(7, DoubleMath.roundToLong(result.get(2).asDouble().getDouble(), RoundingMode.HALF_UP)); assertEquals(4, DoubleMath.roundToLong(result.get(3).asDouble().getDouble(), RoundingMode.HALF_UP)); assertEquals(14, result.get(4).asLong().getLong()); // test mode "get" assertEquals(0, reservoir.getValue("mode||get~epoch||0").asLong().getLong()); assertEquals(4, reservoir.getValue("mode||get~epoch||1").asLong().getLong()); assertEquals(12, reservoir.getValue("mode||get~epoch||2").asLong().getLong()); assertEquals(4, reservoir.getValue("mode||get~epoch||3").asLong().getLong()); assertEquals(100, reservoir.getValue("mode||get~epoch||4").asLong().getLong()); assertEquals(0, reservoir.getValue("mode||get~epoch||5").asLong().getLong()); }