@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(); } }
String html = value.asString().asNative(); if (html == null) { return null;
@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); } } } }
@Override public void process(Bundle row, StreamEmitter emitter) { long emitTimes = defaultRepeats; ValueObject repeatCount = repeatField.getValue(row); if (repeatCount != null) { try { emitTimes = repeatCount.asLong().getLong(); } catch (ValueTranslationException vte) { if (failOnParseException) { throw vte; } else { log.warn("Failed to parse repeats field value={}", repeatCount.asString().asNative()); } } } for (int i = 0; i < emitTimes; i++) { Bundle toEmit = copyBundle ? Bundles.deepCopyBundle(row) : row; // Copy the bundle each time to ensure sanity downstream emitter.emit(toEmit); } } }
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()); }
return value.asString().asNative(); case BYTES: return value.asBytes().asNative();
return value.asString().asNative(); case BYTES: return value.asBytes().asNative();