private ValueArray getTimeRange(long time, int range, TimeUnit timeUnit) { ValueArray arr = ValueFactory.createArray(range); for (int i = 0; i < range; i++) { arr.add(ValueFactory.create(date.print(time + timeUnit.toMillis(i)))); } return arr; }
public static ValueMap create(Map<String, byte[]> input) { if (input == null) { return null; } if (input instanceof MapStringBytes) { return ((MapStringBytes) input).getData(); } else { ValueMap output = ValueFactory.createMap(); for (Map.Entry<String, byte[]> entry : input.entrySet()) { output.put(entry.getKey(), ValueFactory.create(entry.getValue())); } return output; } }
@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); } }
@Override public ValueMap asMap() { ValueMap result = ValueFactory.createMap(); result.put("targetEpoch", ValueFactory.create(targetEpoch)); result.put("numObservations", ValueFactory.create(numObservations)); result.put("doubleToLongBits", ValueFactory.create(doubleToLongBits ? 1 : 0)); result.put("raw", ValueFactory.create(raw ? 1 : 0)); result.put("percentile", ValueFactory.create(percentile)); result.put("sigma", ValueFactory.create(sigma)); result.put("minMeasurement", ValueFactory.create(minMeasurement)); result.put("mode", ValueFactory.create(mode)); result.put("minEpoch", ValueFactory.create(heldObject.minEpoch)); ValueArray reservoir = ValueFactory.createArray(heldObject.reservoir.length); for (int i = 0; i < heldObject.reservoir.length; i++) { reservoir.add(i, ValueFactory.create(heldObject.reservoir[i])); } result.put("reservoir", reservoir); return result; }
@Override public ValueObject getValue(String key) { return ValueFactory.create(deleted); } }
@Override public ValueArray asArray() throws ValueTranslationException { ValueArray arr = ValueFactory.createArray(1); arr.add(this); return arr; }
public static ValueMap create(Map<String, List<String>> input) { if (input == null) { return null; } if (input instanceof MapStringListString) { return ((MapStringListString) input).getData(); } else { ValueMap output = ValueFactory.createMap(); for (Entry<String, List<String>> entry : input.entrySet()) { output.put(entry.getKey(), ListString.create(entry.getValue())); } return output; } }
@Test public void arrayTest() { ValueFilterJoin join = new ValueFilterJoin(); ValueArray strArray = ValueFactory.createValueArray(Arrays.asList("b", "c", "a")); ValueArray numArray = ValueFactory.createArray(3); for (int i = 0; i < 5; i++) { numArray.add(ValueFactory.create(5 - i)); } assertEquals("should correctly join string array", "b,c,a", join.filter(strArray).toString()); join.setSort(true); assertEquals("should correctly sort and join string array", "a,b,c", join.filter(strArray).toString()); join.setSort(false); assertEquals("should correctly join num array", "5,4,3,2,1", join.filter(numArray).toString()); join.setSort(true); assertEquals("should correctly sort and join num array", "1,2,3,4,5", join.filter(numArray).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; } }
@Test public void sortTest() { ValueArray array = ValueFactory.createValueArray(Arrays.asList("aa", "bb", "ab", "ba")); ValueFilterSort sort = new ValueFilterSort(); assertEquals("should sort array correctly", "[aa, ab, ba, bb]", sort.filterValue(array).toString()); } }
@Override public ValueObject getValue(String key) { return ValueFactory.create(deleted); } }
public static ValueArray sortArray(ValueArray array) { List<ValueObject> tmpObjs = new ArrayList<>(); for (ValueObject obj : array) { tmpObjs.add(obj); } Collections.sort(tmpObjs, valueObjectComparator); ValueArray rv = ValueFactory.createArray(array.size()); for (ValueObject obj : tmpObjs) { rv.add(obj); } return rv; } }
@Override public ValueMap asMap() throws ValueTranslationException { ValueMap map = ValueFactory.createMap(); map.put(key, asBytes()); return map; }
public static ValueArray create(List<byte[]> input) { if (input == null) { return null; } if (input instanceof ListBytes) { return ((ListBytes) input).getData(); } else { ValueArray output = ValueFactory.createArray(input.size()); for (byte[] element : input) { output.add(ValueFactory.create(element)); } return output; } }
public static ValueMap create(Map<String, Long> input) { if (input == null) { return null; } if (input instanceof MapStringLong) { return ((MapStringLong) input).getData(); } else { ValueMap output = ValueFactory.createMap(); for (Map.Entry<String, Long> entry : input.entrySet()) { output.put(entry.getKey(), ValueFactory.create(entry.getValue())); } return output; } }
public final ValueObject value() { if (valueString == null) { valueString = ValueFactory.create(value); } return valueString; }
private ValueArray create(ValueObject[] value) { ValueArray a = ValueFactory.createArray(value.length); Collections.addAll(a, value); return a; }
public MapStringDouble(ValueMap map, boolean copy) { if (copy) { this.data = ValueFactory.createMap(); for (ValueMapEntry entry : map) { this.data.put(entry.getKey(), entry.getValue()); } } else { this.data = map; } }
@Test public void contextualLookup() throws IOException { ValueFilter valueFilter = decodeObject(ValueFilter.class, "map { map.field = lookup }"); Bundle bundle = Bundles.decode("lookup = {a = 1, b = 2, c = 3, d = 4}"); ValueObject val = ValueFactory.decodeValue("c"); assertEquals("3", valueFilter.filter(val, bundle).toString()); }
public static ValueArray create(List<String> input) { if (input == null) { return null; } if (input instanceof ListString) { return ((ListString) input).getData(); } else { ValueArray output = ValueFactory.createArray(input.size()); for (String element : input) { output.add(ValueFactory.create(element)); } return output; } }