Java ByteRange.getLength方法代码示例

import org.apache.hadoop.hbase.util.ByteRange; //导入方法依赖的package包/类
protected TokenizerNode addNode(TokenizerNode parent, int nodeDepth, int tokenStartOffset,
    final ByteRange token, int inputTokenOffset) {
  int inputTokenLength = token.getLength() - inputTokenOffset;
  int tokenOffset = appendTokenAndRepointByteRange(token, inputTokenOffset);
  TokenizerNode node = null;
  if (nodes.size() <= numNodes) {
    node = new TokenizerNode(this, parent, nodeDepth, tokenStartOffset, tokenOffset,
        inputTokenLength);
    nodes.add(node);
  } else {
    node = nodes.get(numNodes);
    node.reset();
    node.reconstruct(this, parent, nodeDepth, tokenStartOffset, tokenOffset, inputTokenLength);
  }
  ++numNodes;
  return node;
}
 

import org.apache.hadoop.hbase.util.ByteRange; //导入方法依赖的package包/类
protected int store(ByteRange bytes) {
  int indexOfNewElement = numUniqueRanges;
  if (uniqueRanges.size() <= numUniqueRanges) {
    uniqueRanges.add(new SimpleMutableByteRange());
  }
  ByteRange storedRange = uniqueRanges.get(numUniqueRanges);
  int neededBytes = numBytes + bytes.getLength();
  byteAppender = ArrayUtils.growIfNecessary(byteAppender, neededBytes, 2 * neededBytes);
  bytes.deepCopyTo(byteAppender, numBytes);
  storedRange.set(byteAppender, numBytes, bytes.getLength());// this isn't valid yet
  numBytes += bytes.getLength();
  uniqueIndexByUniqueRange.put(storedRange, indexOfNewElement);
  int newestUniqueIndex = numUniqueRanges;
  ++numUniqueRanges;
  return newestUniqueIndex;
}
 

import org.apache.hadoop.hbase.util.ByteRange; //导入方法依赖的package包/类
protected int store(ByteRange bytes) {
  int indexOfNewElement = numUniqueRanges;
  if (uniqueRanges.size() <= numUniqueRanges) {
    uniqueRanges.add(new SimpleByteRange());
  }
  ByteRange storedRange = uniqueRanges.get(numUniqueRanges);
  int neededBytes = numBytes + bytes.getLength();
  byteAppender = ArrayUtils.growIfNecessary(byteAppender, neededBytes, 2 * neededBytes);
  bytes.deepCopyTo(byteAppender, numBytes);
  storedRange.set(byteAppender, numBytes, bytes.getLength());// this isn't valid yet
  numBytes += bytes.getLength();
  uniqueIndexByUniqueRange.put(storedRange, indexOfNewElement);
  int newestUniqueIndex = numUniqueRanges;
  ++numUniqueRanges;
  return newestUniqueIndex;
}
 

import org.apache.hadoop.hbase.util.ByteRange; //导入方法依赖的package包/类
public void addSorted(final ByteRange bytes) {
  ++numArraysAdded;
  if (bytes.getLength() > maxElementLength) {
    maxElementLength = bytes.getLength();
  }
  if (root == null) {
    // nodeDepth of firstNode (non-root) is 1
    root = addNode(null, 1, 0, bytes, 0);
  } else {
    root.addSorted(bytes);
  }
}
 

import org.apache.hadoop.hbase.util.ByteRange; //导入方法依赖的package包/类
protected int appendTokenAndRepointByteRange(final ByteRange token, int inputTokenOffset) {
  int newOffset = tokensLength;
  int inputTokenLength = token.getLength() - inputTokenOffset;
  int newMinimum = tokensLength + inputTokenLength;
  tokens = ArrayUtils.growIfNecessary(tokens, newMinimum, 2 * newMinimum);
  token.deepCopySubRangeTo(inputTokenOffset, inputTokenLength, tokens, tokensLength);
  tokensLength += inputTokenLength;
  return newOffset;
}
 

import org.apache.hadoop.hbase.util.ByteRange; //导入方法依赖的package包/类
/************************* building *********************************/

  /*
   * <li>Only public method used during the tokenization process
   * <li>Requires that the input ByteRange sort after the previous, and therefore after all previous
   * inputs
   * <li>Only looks at bytes of the input array that align with this node's token
   */
  public void addSorted(final ByteRange bytes) {// recursively build the tree

    /*
     * Recurse deeper into the existing trie structure
     */
    if (matchesToken(bytes) && CollectionUtils.notEmpty(children)) {
      TokenizerNode lastChild = CollectionUtils.getLast(children);
      if (lastChild.partiallyMatchesToken(bytes)) {
        lastChild.addSorted(bytes);
        return;
      }
    }

    /*
     * Recursion ended.  We must either
     * <li>1: increment numOccurrences if this input was equal to the previous
     * <li>2: convert this node from a leaf to a nub, and add a new child leaf
     * <li>3: split this node into a branch and leaf, and then add a second leaf
     */

    // add it as a child of this node
    int numIdenticalTokenBytes = numIdenticalBytes(bytes);// should be <= token.length
    int tailOffset = tokenStartOffset + numIdenticalTokenBytes;
    int tailLength = bytes.getLength() - tailOffset;

    if (numIdenticalTokenBytes == token.getLength()) {
      if (tailLength == 0) {// identical to this node (case 1)
        incrementNumOccurrences(1);
      } else {// identical to this node, but with a few extra tailing bytes. (leaf -> nub) (case 2)
        int childNodeDepth = nodeDepth + 1;
        int childTokenStartOffset = tokenStartOffset + numIdenticalTokenBytes;
        TokenizerNode newChildNode = builder.addNode(this, childNodeDepth, childTokenStartOffset,
          bytes, tailOffset);
        addChild(newChildNode);
      }
    } else {//numIdenticalBytes > 0, split into branch/leaf and then add second leaf (case 3)
      split(numIdenticalTokenBytes, bytes);
    }
  }