Java PackedInts.COMPACT属性代码示例

TermsWriter(FieldInfo fieldInfo) {
  this.fieldInfo = fieldInfo;

  noOutputs = NoOutputs.getSingleton();

  // This Builder is just used transiently to fragment
  // terms into "good" blocks; we don't save the
  // resulting FST:
  blockBuilder = new Builder<Object>(FST.INPUT_TYPE.BYTE1,
                                     0, 0, true,
                                     true, Integer.MAX_VALUE,
                                     noOutputs,
                                     new FindBlocks(), false,
                                     PackedInts.COMPACT,
                                     true, 15);

  this.longsSize = postingsWriter.setField(fieldInfo);
}
 

public BinaryDocValuesFieldUpdates(String field, int maxDoc) {
  super(field, FieldInfo.DocValuesType.BINARY);
  bitsPerValue = PackedInts.bitsRequired(maxDoc - 1);
  docs = new PagedMutable(1, PAGE_SIZE, bitsPerValue, PackedInts.COMPACT);
  offsets = new PagedGrowableWriter(1, PAGE_SIZE, 1, PackedInts.FAST);
  lengths = new PagedGrowableWriter(1, PAGE_SIZE, 1, PackedInts.FAST);
  values = new BytesRefBuilder();
  size = 0;
}
 

public NumericDocValuesFieldUpdates(String field, int maxDoc) {
  super(field, FieldInfo.DocValuesType.NUMERIC);
  bitsPerValue = PackedInts.bitsRequired(maxDoc - 1);
  docs = new PagedMutable(1, PAGE_SIZE, bitsPerValue, PackedInts.COMPACT);
  values = new PagedGrowableWriter(1, PAGE_SIZE, 1, PackedInts.FAST);
  size = 0;
}
 

public BinaryDocValuesWriter(FieldInfo fieldInfo, Counter iwBytesUsed) {
  this.fieldInfo = fieldInfo;
  this.bytes = new PagedBytes(BLOCK_BITS);
  this.bytesOut = bytes.getDataOutput();
  this.lengths = new AppendingDeltaPackedLongBuffer(PackedInts.COMPACT);
  this.iwBytesUsed = iwBytesUsed;
  this.docsWithField = new FixedBitSet(64);
  this.bytesUsed = docsWithFieldBytesUsed();
  iwBytesUsed.addAndGet(bytesUsed);
}
 

public SortedDocValuesWriter(FieldInfo fieldInfo, Counter iwBytesUsed) {
  this.fieldInfo = fieldInfo;
  this.iwBytesUsed = iwBytesUsed;
  hash = new BytesRefHash(
      new ByteBlockPool(
          new ByteBlockPool.DirectTrackingAllocator(iwBytesUsed)),
          BytesRefHash.DEFAULT_CAPACITY,
          new DirectBytesStartArray(BytesRefHash.DEFAULT_CAPACITY, iwBytesUsed));
  pending = new AppendingDeltaPackedLongBuffer(PackedInts.COMPACT);
  bytesUsed = pending.ramBytesUsed();
  iwBytesUsed.addAndGet(bytesUsed);
}
 

public NumericDocValuesWriter(FieldInfo fieldInfo, Counter iwBytesUsed, boolean trackDocsWithField) {
  pending = new AppendingDeltaPackedLongBuffer(PackedInts.COMPACT);
  docsWithField = trackDocsWithField ? new FixedBitSet(64) : null;
  bytesUsed = pending.ramBytesUsed() + docsWithFieldBytesUsed();
  this.fieldInfo = fieldInfo;
  this.iwBytesUsed = iwBytesUsed;
  iwBytesUsed.addAndGet(bytesUsed);
}
 

public SortedSetDocValuesWriter(FieldInfo fieldInfo, Counter iwBytesUsed) {
  this.fieldInfo = fieldInfo;
  this.iwBytesUsed = iwBytesUsed;
  hash = new BytesRefHash(
      new ByteBlockPool(
          new ByteBlockPool.DirectTrackingAllocator(iwBytesUsed)),
          BytesRefHash.DEFAULT_CAPACITY,
          new DirectBytesStartArray(BytesRefHash.DEFAULT_CAPACITY, iwBytesUsed));
  pending = new AppendingPackedLongBuffer(PackedInts.COMPACT);
  pendingCounts = new AppendingDeltaPackedLongBuffer(PackedInts.COMPACT);
  bytesUsed = pending.ramBytesUsed() + pendingCounts.ramBytesUsed();
  iwBytesUsed.addAndGet(bytesUsed);
}
 

/** Creates a postings writer with <code>PackedInts.COMPACT</code> */
public Lucene41PostingsWriter(SegmentWriteState state) throws IOException {
  this(state, PackedInts.COMPACT);
}
 

public NodeHash(FST<T> fst, FST.BytesReader in) {
  table = new PagedGrowableWriter(16, 1<<27, 8, PackedInts.COMPACT);
  mask = 15;
  this.fst = fst;
  this.in = in;
}
 

/** 
 * Creates an ordinal map that allows mapping ords to/from a merged
 * space from <code>subs</code>.
 * @param owner a cache key
 * @param subs TermsEnums that support {@link TermsEnum#ord()}. They need
 *             not be dense (e.g. can be FilteredTermsEnums}.
 * @throws IOException if an I/O error occurred.
 */
public OrdinalMap(Object owner, TermsEnum subs[]) throws IOException {
  // create the ordinal mappings by pulling a termsenum over each sub's 
  // unique terms, and walking a multitermsenum over those
  this.owner = owner;
  globalOrdDeltas = new MonotonicAppendingLongBuffer(PackedInts.COMPACT);
  firstSegments = new AppendingPackedLongBuffer(PackedInts.COMPACT);
  ordDeltas = new MonotonicAppendingLongBuffer[subs.length];
  for (int i = 0; i < ordDeltas.length; i++) {
    ordDeltas[i] = new MonotonicAppendingLongBuffer();
  }
  long segmentOrds[] = new long[subs.length];
  ReaderSlice slices[] = new ReaderSlice[subs.length];
  TermsEnumIndex indexes[] = new TermsEnumIndex[slices.length];
  for (int i = 0; i < slices.length; i++) {
    slices[i] = new ReaderSlice(0, 0, i);
    indexes[i] = new TermsEnumIndex(subs[i], i);
  }
  MultiTermsEnum mte = new MultiTermsEnum(slices);
  mte.reset(indexes);
  long globalOrd = 0;
  while (mte.next() != null) {        
    TermsEnumWithSlice matches[] = mte.getMatchArray();
    for (int i = 0; i < mte.getMatchCount(); i++) {
      int segmentIndex = matches[i].index;
      long segmentOrd = matches[i].terms.ord();
      long delta = globalOrd - segmentOrd;
      // for each unique term, just mark the first segment index/delta where it occurs
      if (i == 0) {
        firstSegments.add(segmentIndex);
        globalOrdDeltas.add(delta);
      }
      // for each per-segment ord, map it back to the global term.
      while (segmentOrds[segmentIndex] <= segmentOrd) {
        ordDeltas[segmentIndex].add(delta);
        segmentOrds[segmentIndex]++;
      }
    }
    globalOrd++;
  }
  firstSegments.freeze();
  globalOrdDeltas.freeze();
  for (int i = 0; i < ordDeltas.length; ++i) {
    ordDeltas[i].freeze();
  }
}
 

public NodeHash(FST<T> fst, FST.BytesReader in) {
  table = new GrowableWriter(8, 16, PackedInts.COMPACT);
  mask = 15;
  this.fst = fst;
  this.in = in;
}
 

/** Creates a postings writer with <code>PackedInts.COMPACT</code> */
public LucurePostingsWriter(SegmentWriteState state) throws IOException {
  this(state, PackedInts.COMPACT);
}
 

public PackedNumericFieldUpdates(int maxDoc) {
  docsWithField = new FixedBitSet(64);
  docs = new PagedMutable(1, 1024, PackedInts.bitsRequired(maxDoc - 1), PackedInts.COMPACT);
  values = new PagedGrowableWriter(1, 1024, 1, PackedInts.FAST);
  size = 0;
}
 

public NodeHash(FST<T> fst, FST.BytesReader in) {
  table = new PagedGrowableWriter(16, 1<<30, 8, PackedInts.COMPACT);
  mask = 15;
  this.fst = fst;
  this.in = in;
}
 

/**
 * Instantiates an FST/FSA builder without any pruning. A shortcut
 * to {@link #Builder(FST.INPUT_TYPE, int, int, boolean,
 * boolean, int, Outputs, boolean, float,
 * boolean, int)} with pruning options turned off.
 */
public Builder(FST.INPUT_TYPE inputType, Outputs<T> outputs) {
  this(inputType, 0, 0, true, true, Integer.MAX_VALUE, outputs, false, PackedInts.COMPACT, true, 15);
}