@Override public Entry<String, String> next() { Entry<String, ValueObject> input = iterator.next(); return new AbstractMap.SimpleEntry<>(input.getKey(), input.getValue().asString().asNative()); }
@Nullable @Override public ValueObject filterValue(@Nullable ValueObject value) { try { if (value == null) { return null; } else { return ValueFactory.decodeValue(value.asString().asNative()); } } catch (IOException ex) { throw new UncheckedIOException(ex); } }
@JsonCreator public StringWithValueFilter(@JsonProperty("input") @Nullable final String input, @JsonProperty("filter") @Nullable final ValueFilter filter) { if (filter == null) { result = input; } else { ValueObject object = filter.filter(ValueFactory.create(input)); result = (object != null) ? object.asString().asNative() : null; } }
@Override public String get(int index) { ValueObject val = data.get(index); if (val == null) return null; return val.asString().asNative(); }
@Override public String remove(int index) { ValueObject prev = data.remove(index); if (prev == null) return null; return prev.asString().asNative(); } }
@Override public String get(Object key) { String stringKey = (String) key; ValueObject val = data.get(stringKey); if (val == null) { return null; } else { return val.asString().asNative(); } }
@Override public String remove(Object key) { String stringKey = (String) key; ValueObject val = data.remove(stringKey); if (val == null) { return null; } else { return val.asString().asNative(); } }
@Override public String set(int index, String element) { ValueObject prev = data.set(index, ValueFactory.create(element)); if (prev == null) return null; return prev.asString().asNative(); }
@Override public String put(String key, String value) { ValueObject val = data.put(key, ValueFactory.create(value)); if (val == null) { return null; } else { return val.asString().asNative(); } }
@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); } }
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); } }
public boolean updateBundleWithMapAppend(Bundle bundle) { for (FieldValue fv : list) { ValueObject oldValue = bundle.getValue(fv.field); ValueMap newValue; if (oldValue == null) { newValue = ValueFactory.createMap(); } else if (oldValue instanceof ValueMap) { newValue = (ValueMap) oldValue; } else { newValue = ValueFactory.createMap(); newValue.put(oldValue.asString().asNative(), oldValue); } newValue.put(fv.value.asString().asNative(), fv.value); bundle.setValue(fv.field, newValue); } return !list.isEmpty(); }
@Override public void process(Bundle row, StreamEmitter emitter) { String keyValue = row.getValue(row.getFormat().getField(key)).asString().asNative(); String hashValue = row.getValue(row.getFormat().getField(hash)).asString().asNative(); if (keyValue != null) { if (currentHash != null && hashValue != null && !currentHash.equals(hashValue)) { releaseMap(emitter); } currentHash = hashValue; joinAndEmit(keyValue, row, emitter); } }
@Override public boolean filter(Bundle row) { if (row == null) { return not; } ValueObject target = field.getValue(row); if (from != null) { String fieldString = target.asString().asNative(); String fromString = ValueUtil.asNativeString(from.getValue(row)); boolean match = fieldString.contains(fromString); return not ? !match : match; } else if (filter != null) { boolean match = filter.filterValue(target) != null; return not ? !match : match; } else { return not; } }
private void insertMapValue(ValueMap map, ValueObject vo) { String valueString = vo.asString().asNative(); String[] elementArray = valueString.split(elementSeparator); for (String element : elementArray) { String[] keyValue = element.split(keySeparator); if (!includeNullValues && keyValue.length != 2) { continue; } String key = keyValue[0]; ValueObject value = keyValue.length > 1 ? ValueFactory.create(keyValue[1]) : null; ValueObject current = map.get(key); if (!appendValues || (current == null)) { map.put(key, value); } else { ValueArray array = current.asArray(); array.add(value); map.put(key, array); } } } }
@Test public void getString() throws Exception { ValueObject value = applyFilter("{key: c}"); assertEquals(value.asString().asNative(), "test"); }
@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 createMap() throws IOException { ValueFilterCreateMap vf = Configs.decodeObject(ValueFilterCreateMap.class, ""); ValueMap result = vf.filter(ValueFactory.create("hello=world,foo=bar")).asMap(); assertEquals("world", result.get("hello").asString().asNative()); assertEquals("bar", result.get("foo").asString().asNative()); result = vf.filter(ValueFactory.create("hello=world,hello=bar")).asMap(); assertEquals("bar", result.get("hello").asString().asNative()); result = vf.filter(ValueFactory.create("hello=world,hello")).asMap(); assertEquals("world", result.get("hello").asString().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); }
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()); }