Best code snippets using org.apache.hyracks.data.std.primitive.ByteArrayPointable(Showing top 15 results out of 315)

@Override
public IPointable createPointable() {
  return new ByteArrayPointable();
}

@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
protected void afterReset() {
  contentLength = getContentLength(getByteArray(), getStartOffset());
  metaLength = getNumberBytesToStoreMeta(contentLength);
  hash = 0;
}

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;
}

public void serialize(ByteArrayPointable byteArrayPtr, DataOutput out) throws HyracksDataException {
  try {
    out.write(byteArrayPtr.getByteArray(), byteArrayPtr.getStartOffset(), byteArrayPtr.getLength());
  } catch (IOException e) {
    throw new HyracksDataException(e);
  }
}

@Override
public void normalize(byte[] bytes, int start, int length, int[] normalizedKeys, int keyStart) {
  normalizedKeys[keyStart] = ByteArrayPointable.normalize(bytes, start);
}

public int getContentStartOffset() {
  return getStartOffset() + getMetaLength();
}

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());
}

@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);
  result.setValue(1L + indexOf(textPtr.getByteArray(), textPtr.getContentStartOffset(),
      textPtr.getContentLength(), wordPtr.getByteArray(), wordPtr.getContentStartOffset(),
      wordPtr.getContentLength(), fromOffset));
  intSerde.serialize(result, dataOutput);
  resultPointable.set(resultStorage);
}

public static byte[] copyContent(ByteArrayPointable bytePtr) {
  return Arrays.copyOfRange(bytePtr.getByteArray(), bytePtr.getContentStartOffset(),
      bytePtr.getContentStartOffset() + bytePtr.getContentLength());
}

  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();
      - 1;
  int totalLength = byteArrayPointable.getContentLength();
  int subLength = getSubLength(tuple);
  int metaLength = VarLenIntEncoderDecoder.encode(subLength, metaBuffer, 0);
  dataOutput.write(metaBuffer, 0, metaLength);
  dataOutput.write(byteArrayPointable.getByteArray(), byteArrayPointable.getContentStartOffset() + subStart,
      subLength);
} catch (IOException 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 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 int getLength() {
  return getContentLength() + getMetaLength();
}