public FieldValue create() { return new IntegerFieldValue(); } }
private static FieldValue parseInteger(String str) { if (str.startsWith("0x")) { return new IntegerFieldValue(new BigInteger(str.substring(2), 16).intValue()); } else { return new IntegerFieldValue(new BigInteger(str).intValue()); } }
@Override public Serializer putShort(FieldBase field, short value) { singleValueTag(field, new IntegerFieldValue(value)); return this; }
@Override public Serializer putInt(FieldBase field, int value) { singleValueTag(field, new IntegerFieldValue(value)); return this; }
public final FieldValue setFieldValue(Field field, Integer value) { return setFieldValue(field, new IntegerFieldValue(value)); }
public final FieldValue setFieldValue(String field, Integer value) { return setFieldValue(field, new IntegerFieldValue(value)); }
@Override protected void doExecute(ExecutionContext ctx) { int max; if (this.max != null) { max = this.max; } else { max = Integer.parseInt(String.valueOf(ctx.getValue())); } ctx.setValue(new IntegerFieldValue(ThreadLocalRandom.current().nextInt(max))); }
public static Struct valueOf(Integer x, Integer y) { Struct ret = new Struct(INSTANCE); ret.setFieldValue(FIELD_X, x != null ? new IntegerFieldValue(x) : null); ret.setFieldValue(FIELD_Y, y != null ? new IntegerFieldValue(y) : null); return ret; }
@Override protected void doExecute(ExecutionContext ctx) { ctx.setValue(new IntegerFieldValue(Integer.valueOf(String.valueOf(ctx.getValue())))); }
private FieldValue createFieldValue(FieldValue lhs, FieldValue rhs, BigDecimal val) { if (lhs instanceof FloatFieldValue || lhs instanceof DoubleFieldValue || rhs instanceof FloatFieldValue || rhs instanceof DoubleFieldValue) { if (lhs instanceof DoubleFieldValue || rhs instanceof DoubleFieldValue) { return new DoubleFieldValue(val.doubleValue()); } return new FloatFieldValue(val.floatValue()); } if (lhs instanceof LongFieldValue || rhs instanceof LongFieldValue) { return new LongFieldValue(val.longValue()); } return new IntegerFieldValue(val.intValue()); }
/** * Convenience method for adding an annotation to this span, same as * <code>getSpanTree().{@link SpanTree#annotate(SpanNode,AnnotationType,FieldValue) spanTree.annotate(this,type,new IntegerFieldValue(value))}</code> * * @param type the type of the annotation to add * @param value the integer value of the annotation to add * @return this for chaining * @throws NullPointerException if this span is not attached to a tree */ public SpanNode annotate(AnnotationType type,Integer value) { getNonNullSpanTree().annotate(this, type, new IntegerFieldValue(value)); return this; }
@SuppressWarnings({ "unchecked" }) private List<ValueUpdate> createMapValueUpdatesForWset(WeightedSet wset, MapValueUpdate upd) { List<ValueUpdate> ret = new ArrayList<>(); for (Iterator<FieldValue> it = wset.fieldValueIterator(); it.hasNext();) { FieldValue childVal = it.next(); for (ValueUpdate childUpd : createValueUpdates(new IntegerFieldValue(wset.get(childVal)), upd.getUpdate())) { ret.add(new MapValueUpdate(childVal, childUpd)); } } return ret; } }
private static FieldValue keyTypeForMapUpdate(TokenBuffer.Token element, DataType expectedType) { FieldValue v; if (expectedType instanceof ArrayDataType) { v = new IntegerFieldValue(Integer.valueOf(element.text)); } else if (expectedType instanceof WeightedSetDataType) { v = ((WeightedSetDataType) expectedType).getNestedType().createFieldValue(element.text); } else if (expectedType instanceof MapDataType) { v = ((MapDataType) expectedType).getKeyType().createFieldValue(element.text); } else { throw new IllegalArgumentException("Container type " + expectedType + " not supported for match update."); } return v; } }
public Document createRandomDocumentAtLocation(long location, long timestamp, int minSize, int maxSize) { Document document = new Document(getDocumentType("testdoctype1"), new DocumentId("userdoc:footype:" + location + ":" + timestamp)); document.setFieldValue("headerval", new IntegerFieldValue((int)timestamp)); StringBuffer value = new StringBuffer(); int length = (int)(Math.random() * (maxSize - minSize)) + minSize; for (int i = 0; i < length; ++i) { value.append("A"); } document.setFieldValue("content", new StringFieldValue(value.toString())); return document; } }
/** * Add a key with an associated weight to this set. If the key is already present in this set, the previous * association is replaced. Checks to validate that all keys are of the same type. * * @param key the key to add * @param weight the weight to associate with this key * @return the weight that was previously associated with this key, or null (if there was no previous key) */ public Integer put(K key, Integer weight) { verifyElementCompatibility(key); IntegerFieldValue ifv = putUnChecked(key, new IntegerFieldValue(weight)); return ifv != null ? ifv.getInteger() : null; }
private Expression makeSetPredicateVariablesScript(BooleanIndexDefinition options) { List<Expression> expressions = new ArrayList<>(); expressions.add(new SetValueExpression(new IntegerFieldValue(options.getArity()))); expressions.add(new SetVarExpression("arity")); if (options.hasLowerBound()) { expressions.add(new SetValueExpression(new LongFieldValue(options.getLowerBound()))); expressions.add(new SetVarExpression("lower_bound")); } if (options.hasUpperBound()) { expressions.add(new SetValueExpression(new LongFieldValue(options.getUpperBound()))); expressions.add(new SetVarExpression("upper_bound")); } return new StatementExpression(expressions); }
void testIterateMatchSelection(PersistenceProvider spi) throws Exception { Bucket b = new Bucket((short)0, new BucketId(8, 0x1)); spi.createBucket(b); List<DocEntry> docsToVisit = new ArrayList<DocEntry>(); for (int i = 0; i < 99; i++) { Document doc = testDocMan.createRandomDocumentAtLocation(1, 1000 + i, 110, 110); doc.setFieldValue("headerval", new IntegerFieldValue(i)); spi.put(b, 1000 + i, doc); if ((i % 3) == 0) { docsToVisit.add(new DocEntry(1000 + i, doc)); } } spi.flush(b); CreateIteratorResult iter = spi.createIterator(b, new AllFields(), new Selection("testdoctype1.headerval % 3 == 0", 0, Long.MAX_VALUE), PersistenceProvider.IncludedVersions.NEWEST_DOCUMENT_ONLY); List<IterateResult> chunks = doIterate(spi, iter.getIteratorId(), 2048, 0); verifyDocs(docsToVisit, chunks); spi.destroyIterator(iter.getIteratorId()); }
public <T extends FieldValue> void read(FieldBase field, WeightedSet<T> ws) { WeightedSetDataType type = ws.getDataType(); getInt(null); // Have no need for type int numElements = getInt(null); if (numElements < 0) { throw new DeserializationException("Bad number of weighted set elements, " + numElements); } ws.clearAndReserve(numElements * 2); // Avoid resizing for (int i = 0; i < numElements; i++) { int size = getInt(null); FieldValue value = type.getNestedType().createFieldValue(); value.deserialize(null, this); IntegerFieldValue weight = new IntegerFieldValue(getInt(null)); ws.putUnChecked((T) value, weight); } }
public <T extends FieldValue> void read(FieldBase field, WeightedSet<T> ws) { WeightedSetDataType type = ws.getDataType(); getInt(null); // Have no need for type int numElements = getInt(null); if (numElements < 0) { throw new DeserializationException("Bad number of weighted set elements, " + numElements); } ws.clearAndReserve(numElements * 2); // Avoid resizing for (int i = 0; i < numElements; i++) { int size = getInt(null); FieldValue value = type.getNestedType().createFieldValue(); value.deserialize(null, this); IntegerFieldValue weight = new IntegerFieldValue(getInt(null)); ws.putUnChecked((T) value, weight); } }
void testIterateAllDocsNewestVersionOnly(PersistenceProvider spi) throws Exception { Bucket b = new Bucket((short)0, new BucketId(8, 0x1)); spi.createBucket(b); List<DocEntry> docs = feedDocs(spi, b, 100, 110, 110); List<DocEntry> newDocs = new ArrayList<DocEntry>(); for (DocEntry e : docs) { Document newDoc = e.getDocument().clone(); newDoc.setFieldValue("headerval", new IntegerFieldValue(5678 + (int)e.getTimestamp())); spi.put(b, 1000 + e.getTimestamp(), newDoc); newDocs.add(new DocEntry(1000 + e.getTimestamp(), newDoc)); } spi.flush(b); CreateIteratorResult iter = spi.createIterator(b, new AllFields(), new Selection("", 0, Long.MAX_VALUE), PersistenceProvider.IncludedVersions.NEWEST_DOCUMENT_ONLY); List<IterateResult> chunks = doIterate(spi, iter.getIteratorId(), 4096, 0); verifyDocs(newDocs, chunks); spi.destroyIterator(iter.getIteratorId()); }