@Override protected void afterReset() { contentLength = getContentLength(getByteArray(), getStartOffset()); metaLength = getNumberBytesToStoreMeta(contentLength); hash = 0; }
public static byte[] copyContent(ByteArrayPointable bytePtr) { return Arrays.copyOfRange(bytePtr.getByteArray(), bytePtr.getContentStartOffset(), bytePtr.getContentStartOffset() + bytePtr.getContentLength()); }
public static ByteArrayPointable generatePointableFromPureBytes(byte[] bytes, int start, int length) { int metaLen = getNumberBytesToStoreMeta(length); byte[] ret = new byte[length + metaLen]; VarLenIntEncoderDecoder.encode(length, ret, 0); for (int i = 0; i < length; ++i) { ret[i + metaLen] = bytes[start + i]; } ByteArrayPointable ptr = new ByteArrayPointable(); ptr.set(ret, 0, ret.length); return ptr; }
@Override public int hash() { if (hash == 0) { int h = 0; int realLength = getContentLength(); int startOffset = getContentStartOffset(); for (int i = 0; i < realLength; ++i) { h = 31 * h + bytes[startOffset + i]; } hash = h; } return hash; }
@Override public int compareTo(byte[] thatBytes, int thatStart, int thatLength) { int thisArrayLen = getContentLength(this.bytes, this.start); int thatArrayLen = getContentLength(thatBytes, thatStart); int thisArrayStart = this.getContentStartOffset(); int thatArrayStart = thatStart + getNumberBytesToStoreMeta(thatArrayLen); for (int thisIndex = 0, thatIndex = 0; thisIndex < thisArrayLen && thatIndex < thatArrayLen; ++thisIndex, ++thatIndex) { if (this.bytes[thisArrayStart + thisIndex] != thatBytes[thatArrayStart + thatIndex]) { return (0xff & this.bytes[thisArrayStart + thisIndex]) - (0xff & thatBytes[thatArrayStart + thatIndex]); } } return thisArrayLen - thatArrayLen; }
@Override public void evaluate(IFrameTupleReference tuple, IPointable resultPointable) throws HyracksDataException { resultStorage.reset(); for (int i = 0; i < pointables.length; ++i) { evaluators[i].evaluate(tuple, pointables[i]); } int fromOffset = getFromOffset(tuple); ATypeTag textTag = ATypeTag.VALUE_TYPE_MAPPING[pointables[0].getByteArray()[pointables[0].getStartOffset()]]; ATypeTag wordTag = ATypeTag.VALUE_TYPE_MAPPING[pointables[1].getByteArray()[pointables[1].getStartOffset()]]; checkTypeMachingThrowsIfNot(functionName, EXPECTED_INPUT_TAG, textTag, wordTag); textPtr.set(pointables[0].getByteArray(), pointables[0].getStartOffset() + 1, pointables[0].getLength() - 1); wordPtr.set(pointables[1].getByteArray(), pointables[0].getStartOffset() + 1, pointables[1].getLength() - 1); int pos = indexOf(textPtr.getByteArray(), textPtr.getContentStartOffset(), textPtr.getContentLength(), wordPtr.getByteArray(), wordPtr.getContentStartOffset(), wordPtr.getContentLength(), fromOffset); result.setValue(pos < 0 ? pos : pos + baseOffset); intSerde.serialize(result, dataOutput); resultPointable.set(resultStorage); }
public void serialize(ByteArrayPointable byteArrayPtr, DataOutput out) throws HyracksDataException { try { out.write(byteArrayPtr.getByteArray(), byteArrayPtr.getStartOffset(), byteArrayPtr.getLength()); } catch (IOException e) { throw HyracksDataException.create(e); } }
/** * Compute the normalized key of the byte array. * The normalized key in Hyracks is mainly used to speedup the comparison between pointable data. * In the ByteArray case, we compute the integer value by using the first 4 bytes. * The comparator will first use this integer to get the result ( <,>, or =), it will check * the actual bytes only if the normalized key is equal. Thus this normalized key must be * consistent with the comparison result. * * @param bytesPtr * @param start * @return */ public static int normalize(byte[] bytesPtr, int start) { int len = getContentLength(bytesPtr, start); long nk = 0; start = start + getNumberBytesToStoreMeta(len); for (int i = 0; i < 4; ++i) { nk <<= 8; if (i < len) { nk |= bytesPtr[start + i] & 0xff; } } return (int) (nk >> 1); // make it always positive. }
@Override public int getLength() { return getContentLength() + getMetaLength(); }
public int getContentStartOffset() { return getStartOffset() + getMetaLength(); }
@Override public IPointable createPointable() { return new ByteArrayPointable(); }
public static ByteArrayPointable generatePointableFromPureBytes(byte[] bytes) { return generatePointableFromPureBytes(bytes, 0, bytes.length); }
@Override public int compareTo(IPointable pointer) { return compareTo(pointer.getByteArray(), pointer.getStartOffset(), pointer.getLength()); }
checkTypeMachingThrowsIfNot(functionName, EXPECTED_INPUT_TAGS, argTag0, argTag1); byteArrayPointable.set(pointables[0].getByteArray(), pointables[0].getStartOffset() + 1, pointables[0].getLength() - 1); byte[] startBytes = pointables[1].getByteArray(); - baseOffset; int totalLength = byteArrayPointable.getContentLength(); int subLength = getSubLength(tuple); dataOutput.write(metaBuffer, 0, metaLength); dataOutput.write(byteArrayPointable.getByteArray(), byteArrayPointable.getContentStartOffset() + subStart, subLength); } catch (IOException e) {
int len = ByteArrayPointable.getContentLength(serNonTaggedAObject, offset + 1); return len + ByteArrayPointable.getNumberBytesToStoreMeta(len); } else { int len = ByteArrayPointable.getContentLength(serNonTaggedAObject, offset); return len + ByteArrayPointable.getNumberBytesToStoreMeta(len);