@Override public void setCurrentDateTime(IValueReference value) { if (currentDateTime == null) { currentDateTime = new byte[value.getLength()]; } System.arraycopy(value.getByteArray(), value.getStartOffset(), currentDateTime, 0, value.getLength()); }
public static ATypeTag getTypeTag(IValueReference visitablePointable) { byte[] bytes = visitablePointable.getByteArray(); int s = visitablePointable.getStartOffset(); return EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(bytes[s]); }
@Override public int getOffset(IValueReference key) { int index = find(key); if (index >= 0) { int offset = getTupleStart(index); return offset + key.getLength() + 2 * Integer.BYTES; } return -1; }
@Override public void get(IValueReference key, IPointable value) { int tupleCount = getTupleCount(); int tupleStart = getTupleStart(0); for (int i = 0; i < tupleCount; i++) { if (isInner(key, tupleStart)) { get(tupleStart + key.getLength() + Integer.BYTES, value); return; } tupleStart = getNextTupleStart(tupleStart); } value.set(null, 0, 0); }
private int compare(IValueReference a, IValueReference b) throws HyracksDataException { // start+1 and len-1 due to the type tag return fieldNameComparator.compare(a.getByteArray(), a.getStartOffset() + 1, a.getLength() - 1, b.getByteArray(), b.getStartOffset() + 1, b.getLength() - 1); } }
public static int compareStringBinValues(IValueReference a, IValueReference b, IBinaryComparator comparator) throws HyracksDataException { // start+1 and len-1 due to type tag ignore (only interested in String value) return comparator.compare(a.getByteArray(), a.getStartOffset() + 1, a.getLength() - 1, b.getByteArray(), b.getStartOffset() + 1, b.getLength() - 1); }
public void setContent(IValueReference value) throws IOException { out.write(value.getByteArray(), value.getStartOffset(), value.getLength()); } }
public void setValue(IValueReference value) throws IOException { out.write(value.getByteArray(), value.getStartOffset(), value.getLength()); } }
public void setValue(IValueReference value) throws IOException { out.write(value.getByteArray(), value.getStartOffset(), value.getLength()); } }
public void setValue(IValueReference value) throws IOException { out.write(value.getByteArray(), value.getStartOffset(), value.getLength()); }
public void setTarget(IValueReference value) throws IOException { out.write(value.getByteArray(), value.getStartOffset(), value.getLength()); }
/** * Copies the content of this pointable to the passed byte array. * the array is expected to be at least of length = length of this pointable * * @param value * the value to be copied * @param copy * the array to write into * @throws ArrayIndexOutOfBoundsException * if the passed array size is smaller than length */ public static void copyInto(IValueReference value, byte[] copy) { System.arraycopy(value.getByteArray(), value.getStartOffset(), copy, 0, value.getLength()); }
/** * Copies the content of this pointable to the passed byte array. * the array is expected to be at least of length = offset + length of this pointable * * @param value * the value to be copied * @param copy * the array to write into * @param offset * the offset to start writing from * @throws ArrayIndexOutOfBoundsException * if the passed array size - offset is smaller than length */ public static void copyInto(IValueReference value, byte[] copy, int offset) { System.arraycopy(value.getByteArray(), value.getStartOffset(), copy, offset, value.getLength()); }
/** * Adds a new field and fills it with the content of the passed value */ public void addField(IValueReference data) throws HyracksDataException { addField(data.getByteArray(), data.getStartOffset(), data.getLength()); } }
/** * Check whether two value references are equals * * @param first * first value * @param second * second value * @return true if the two values are equal, false otherwise */ public static boolean equals(IValueReference first, IValueReference second) { // NOSONAR if (first.getLength() != second.getLength()) { return false; } return equalsInRange(first.getByteArray(), first.getStartOffset(), second.getByteArray(), second.getStartOffset(), first.getLength()); }
@Override public void set(IValueReference pointer) { set(pointer.getByteArray(), pointer.getStartOffset(), pointer.getLength()); } }
/** * Compare two value references using given comparator * * @param first * first value * @param second * second value * @param cmp * comparator */ public static int compare(IValueReference first, IValueReference second, IBinaryComparator cmp) throws HyracksDataException { return cmp.compare(first.getByteArray(), first.getStartOffset(), first.getLength(), second.getByteArray(), second.getStartOffset(), second.getLength()); } }
public static boolean byteArrayEqual(IValueReference valueRef1, IValueReference valueRef2, int dataOffset) { if (valueRef1 == null || valueRef2 == null) { return false; } if (valueRef1 == valueRef2) { return true; } int length1 = valueRef1.getLength(); int length2 = valueRef2.getLength(); if (length1 != length2) { return false; } byte[] bytes1 = valueRef1.getByteArray(); byte[] bytes2 = valueRef2.getByteArray(); int start1 = valueRef1.getStartOffset() + dataOffset; int start2 = valueRef2.getStartOffset() + dataOffset; int end = start1 + length1 - dataOffset; for (int i = start1, j = start2; i < end; i++, j++) { if (bytes1[i] != bytes2[j]) { return false; } } return true; }
public static <T extends IValueReference> T findItem(IValueReference item, List<T> sameHashes, IBinaryComparator comp) throws HyracksDataException { T sameItem; for (int k = 0; k < sameHashes.size(); k++) { sameItem = sameHashes.get(k); if (comp.compare(item.getByteArray(), item.getStartOffset(), item.getLength(), sameItem.getByteArray(), sameItem.getStartOffset(), sameItem.getLength()) == 0) { return sameItem; } } return null; } }
@Override public void set(IValueReference ivf) { set(ivf.getByteArray(), ivf.getStartOffset(), ivf.getLength()); }