ValueArray valueArray = value.asArray(); List<Object> list = new ArrayList<>(valueArray.size()); for (ValueObject valueObject : valueArray) { ValueMap map = value.asMap(); Map<String, Object> avroMap = new HashMap<>(value.asMap().size()); for (ValueMapEntry valueMapEntry : map) { avroMap.put(valueMapEntry.getKey(), getAvroNativeFromValue(valueMapEntry.getValue(), return value.asString().asNative(); case BYTES: return value.asBytes().asNative(); case INT: return value.asLong().asNative().intValue(); case LONG: return value.asLong().getLong(); case FLOAT: return value.asDouble().asNative().floatValue(); case DOUBLE: return value.asDouble().getDouble(); case BOOLEAN: return Boolean.valueOf(value.toString()); return value.asNative();
@Override public ValueObject filterValue(ValueObject value) { if (value == null) { return null; } boolean empty = false; switch (value.getObjectType()) { case ARRAY: empty = value.asArray().size() == 0; break; case MAP: empty = value.asMap().size() == 0; break; default: String s = ValueUtil.asNativeString(value); empty = s != null && s.length() == 0; break; } if (not) { return empty ? null : value; } else { return empty ? value : null; } }
@Override protected ValueObject convert(ValueObject nextValue) { if (nextValue.getObjectType() != ValueObject.TYPE.ARRAY) { return nextValue.asString(); } else { return nextValue; } }
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; } 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 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()); }
@Override public Entry<String, Long> next() { Entry<String, ValueObject> input = iterator.next(); return new SimpleEntry<>(input.getKey(), input.getValue().asLong().getLong()); }
@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 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 Entry<String, String> next() { Entry<String, ValueObject> input = iterator.next(); return new AbstractMap.SimpleEntry<>(input.getKey(), input.getValue().asString().asNative()); }
assertTrue(row1.mergedRow[0].asDouble().getDouble() == row2.mergedRow[0].asDouble().getDouble()); assertTrue(row1.mergedRow[1].asString().asNative().equals(row2.mergedRow[1].asString().asNative())); assertTrue(row1.mergedRow[2].asLong().getLong() == row2.mergedRow[2].asLong().getLong()); byte[] row2bytes = row1.mergedRow[3].asBytes().asNative(); assertTrue(row2bytes.length == 4); assertTrue(row2bytes[0] == 5); assertTrue(row2bytes[2] == 7); assertTrue(row2bytes[3] == 100); assertTrue(row1.mergedRow[4].asLong().getLong() == row2.mergedRow[4].asLong().getLong());
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()); }
@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()); }
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 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()); }
@Override public void setValues(ValueMap valueMapEntries) { byte[] b = valueMapEntries.get("b").asBytes().asNative(); this.quantile = valueMapEntries.get("q").asDouble().getDouble(); this.op = OP.valueOf(valueMapEntries.get("o").asString().toString()); heldObject = TDigest.fromBytes(ByteBuffer.wrap(b)); }
@Override public Entry<String, List<String>> next() { Entry<String, ValueObject> input = iterator.next(); return new SimpleEntry<>(input.getKey(), new ListString(input.getValue().asArray(), false)); }
@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 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 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; } }