/** * Constructs a copy of the input annotation. * * @param other annotation */ public Annotation(Annotation other) { this.type = other.type; this.value = ((other.value == null) ? null : other.value.clone()); //do not copy spanNode now }
/** * Clones this AnnotationReference. Note: No deep-copying, so the AnnotationReference returned * refers to the same Annotation as this AnnotationReference. * * @return a copy of this object, referring to the same Annotation instance. */ @Override public AnnotationReference clone() { return (AnnotationReference) super.clone(); //do not clone annotation that we're referring to. See wizardry in SpanTree for that. }
@Override public ModificationStatus doModify(FieldValue fieldVal) { doModifyCalled = true; prevVal = fieldVal.clone(); return ModificationStatus.REMOVED; } }
@Override public BoolFieldValue clone() { return (BoolFieldValue)super.clone(); }
@Override public ModificationStatus doModify(FieldValue fieldVal) { doModifyCalled = true; prevVal = fieldVal.clone(); fieldVal.assign(nextVal); return ModificationStatus.MODIFIED; } }
@Override public Array<T> clone() { Array<T> array = (Array<T>) super.clone(); array.values = new ArrayList<>(values.size()); for (T fval : values) { array.values.add((T) fval.clone()); } return array; }
@Override public PredicateFieldValue clone() { PredicateFieldValue obj = (PredicateFieldValue)super.clone(); if (predicate != null) { try { obj.predicate = predicate.clone(); } catch (CloneNotSupportedException e) { throw new AssertionError(e); } } return obj; }
@Override public Raw clone() { Raw raw = (Raw) super.clone(); if (value.hasArray()) { raw.value = ByteBuffer.wrap(Arrays.copyOf(value.array(), value.array().length)); raw.value.position(value.position()); } else { byte[] copyBuf = new byte[value.capacity()]; int origPos = value.position(); value.position(0); value.get(copyBuf); value.position(origPos); raw.value = ByteBuffer.wrap(copyBuf); raw.value.position(value.position()); } return raw; }
/** * Clones this StringFieldValue and its span trees. * * @return a new deep-copied StringFieldValue */ @Override public StringFieldValue clone() { StringFieldValue strfval = (StringFieldValue) super.clone(); if (spanTrees != null) { strfval.spanTrees = new HashMap<String, SpanTree>(spanTrees.size()); for (Map.Entry<String, SpanTree> entry : spanTrees.entrySet()) { strfval.spanTrees.put(entry.getKey(), new SpanTree(entry.getValue())); } } return strfval; }
iter.remove(); } else { FieldValue copy = currentValue.clone(); copy.clear(); if (currentValue.equals(copy)) {
@Override public Struct clone() { Struct struct = (Struct) super.clone(); struct.values = new Hashlet<>(); struct.values.reserve(values.size()); for (int i = 0; i < values.size(); i++) { struct.values.put(values.key(i), values.value(i).clone()); } return struct; }