Java FixedBitSet.set方法代码示例

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
/**
 * Marks the processing of the provided sequence number as completed as updates the checkpoint if possible.
 *
 * @param seqNo the sequence number to mark as completed
 */
public synchronized void markSeqNoAsCompleted(final long seqNo) {
    // make sure we track highest seen sequence number
    if (seqNo >= nextSeqNo) {
        nextSeqNo = seqNo + 1;
    }
    if (seqNo <= checkpoint) {
        // this is possible during recovery where we might replay an operation that was also replicated
        return;
    }
    final FixedBitSet bitSet = getBitSetForSeqNo(seqNo);
    final int offset = seqNoToBitSetOffset(seqNo);
    bitSet.set(offset);
    if (seqNo == checkpoint + 1) {
        updateCheckpoint();
    }
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
public void testSingleValuedLongs() throws Exception {
    final int numDocs = scaledRandomIntBetween(1, 100);
    final long[] array = new long[numDocs];
    final FixedBitSet docsWithValue = randomBoolean() ? null : new FixedBitSet(numDocs);
    for (int i = 0; i < array.length; ++i) {
        if (randomBoolean()) {
            array[i] = randomLong();
            if (docsWithValue != null) {
                docsWithValue.set(i);
            }
        } else if (docsWithValue != null && randomBoolean()) {
            docsWithValue.set(i);
        }
    }
    final NumericDocValues singleValues = new NumericDocValues() {
        @Override
        public long get(int docID) {
            return array[docID];
        }
    };
    final SortedNumericDocValues multiValues = DocValues.singleton(singleValues, docsWithValue);
    verify(multiValues, numDocs);
    final FixedBitSet rootDocs = randomRootDocs(numDocs);
    final FixedBitSet innerDocs = randomInnerDocs(rootDocs);
    verify(multiValues, numDocs, rootDocs, innerDocs);
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
public void testSingleValuedDoubles() throws Exception  {
    final int numDocs = scaledRandomIntBetween(1, 100);
    final double[] array = new double[numDocs];
    final FixedBitSet docsWithValue = randomBoolean() ? null : new FixedBitSet(numDocs);
    for (int i = 0; i < array.length; ++i) {
        if (randomBoolean()) {
            array[i] = randomDouble();
            if (docsWithValue != null) {
                docsWithValue.set(i);
            }
        } else if (docsWithValue != null && randomBoolean()) {
            docsWithValue.set(i);
        }
    }
    final NumericDoubleValues singleValues = new NumericDoubleValues() {
        @Override
        public double get(int docID) {
            return array[docID];
        }
    };
    final SortedNumericDoubleValues multiValues = FieldData.singleton(singleValues, docsWithValue);
    verify(multiValues, numDocs);
    final FixedBitSet rootDocs = randomRootDocs(numDocs);
    final FixedBitSet innerDocs = randomInnerDocs(rootDocs);
    verify(multiValues, numDocs, rootDocs, innerDocs);
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
private static FixedBitSet getSeqNosSet(final IndexReader reader, final long highestSeqNo) throws IOException {
    // _seq_no are stored as doc values for the time being, so this is how we get them
    // (as opposed to using an IndexSearcher or IndexReader)
    final FixedBitSet bitSet = new FixedBitSet((int) highestSeqNo + 1);
    final List<LeafReaderContext> leaves = reader.leaves();
    if (leaves.isEmpty()) {
        return bitSet;
    }

    for (int i = 0; i < leaves.size(); i++) {
        final LeafReader leaf = leaves.get(i).reader();
        final NumericDocValues values = leaf.getNumericDocValues(SeqNoFieldMapper.NAME);
        if (values == null) {
            continue;
        }
        final Bits bits = leaf.getLiveDocs();
        for (int docID = 0; docID < leaf.maxDoc(); docID++) {
            if (bits == null || bits.get(docID)) {
                final long seqNo = values.get(docID);
                assertFalse("should not have more than one document with the same seq_no[" + seqNo + "]", bitSet.get((int) seqNo));
                bitSet.set((int) seqNo);
            }
        }
    }
    return bitSet;
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
@Override
public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
  current = new FixedBitSet(context.reader().maxDoc());
  fixedBitSets.add(context.ord, current);

  return new LeafCollector() {

    @Override
    public void setScorer(Scorer scorer) throws IOException {}

    @Override
    public void collect(int doc) throws IOException {
      current.set(doc);
      totalHits++;
    }

  };
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
static void generate(int maxSize, int bitsToSet) {
  bs = new FixedBitSet(maxSize);
  ids = new int[bitsToSet];
  int count=0;
  if (maxSize>0) {
    for (int i=0; i<bitsToSet; i++) {
      int id=rand.nextInt(maxSize);
      if (!bs.get(id)) {
        bs.set(id);
        ids[count++]=id;
      }
    }
  }
  bds = new BitDocSet(bs,bitsToSet);
  hds = new HashDocSet(ids,0,count);
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
Bits randomLiveDocs(int maxDoc) {
  if (rarely()) {
    if (random().nextBoolean()) {
      return null;
    } else {
      return new Bits.MatchNoBits(maxDoc);
    }
  }
  final FixedBitSet bits = new FixedBitSet(maxDoc);
  final int bitsSet = TestUtil.nextInt(random(), 1, maxDoc - 1);
  for (int i = 0; i < bitsSet; ++i) {
    while (true) {
      final int index = random().nextInt(maxDoc);
      if (!bits.get(index)) {
        bits.set(index);
        break;
      }
    }
  }
  return bits;
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
private void verifyCount(IndexReader ir) throws Exception {
  Fields fields = MultiFields.getFields(ir);
  if (fields == null) {
    return;
  }
  for (String field : fields) {
    Terms terms = fields.terms(field);
    if (terms == null) {
      continue;
    }
    int docCount = terms.getDocCount();
    FixedBitSet visited = new FixedBitSet(ir.maxDoc());
    TermsEnum te = terms.iterator(null);
    while (te.next() != null) {
      DocsEnum de = TestUtil.docs(random(), te, null, null, DocsEnum.FLAG_NONE);
      while (de.nextDoc() != DocIdSetIterator.NO_MORE_DOCS) {
        visited.set(de.docID());
      }
    }
    assertEquals(visited.cardinality(), docCount);
  }
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
@Override
protected void fillDocsAndScores(FixedBitSet matchingDocs, Bits acceptDocs, TermsEnum termsEnum) throws IOException {
  BytesRef spare = new BytesRef();
  DocsEnum docsEnum = null;
  for (int i = 0; i < terms.size(); i++) {
    if (termsEnum.seekExact(terms.get(ords[i], spare))) {
      docsEnum = termsEnum.docs(acceptDocs, docsEnum, DocsEnum.FLAG_NONE);
      float score = TermsIncludingScoreQuery.this.scores[ords[i]];
      for (int doc = docsEnum.nextDoc(); doc != DocIdSetIterator.NO_MORE_DOCS; doc = docsEnum.nextDoc()) {
        // I prefer this:
        /*if (scores[doc] < score) {
          scores[doc] = score;
          matchingDocs.set(doc);
        }*/
        // But this behaves the same as MVInnerScorer and only then the tests will pass:
        if (!matchingDocs.get(doc)) {
          scores[doc] = score;
          matchingDocs.set(doc);
        }
      }
    }
  }
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
@Override
public DocIdSet getDocIdSet(AtomicReaderContext context, Bits acceptDocs) throws IOException {
  final int maxDoc = context.reader().maxDoc();
  final FieldCache.Ints idSource = FieldCache.DEFAULT.getInts(context.reader(), "id", false);
  assertNotNull(idSource);
  final FixedBitSet bits = new FixedBitSet(maxDoc);
  for(int docID=0;docID<maxDoc;docID++) {
    if (random.nextFloat() <= density && (acceptDocs == null || acceptDocs.get(docID))) {
      bits.set(docID);
      //System.out.println("  acc id=" + idSource.get(docID) + " docID=" + docID + " id=" + idSource.get(docID) + " v=" + docValues.get(idSource.get(docID)).utf8ToString());
      matchValues.add(docValues.get(idSource.get(docID)));
    }
  }

  return bits;
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
/**
 * Builds a {@link BitSet} where each documents bit is that that has one or more ordinals associated with it.
 * if every document has an ordinal associated with it this method returns <code>null</code>
 */
public BitSet buildDocsWithValuesSet() {
    if (numDocsWithValue == maxDoc) {
        return null;
    }
    final FixedBitSet bitSet = new FixedBitSet(maxDoc);
    for (int docID = 0; docID < maxDoc; ++docID) {
        if (ordinals.firstOrdinals.get(docID) != 0) {
            bitSet.set(docID);
        }
    }
    return bitSet;
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
private static FixedBitSet randomRootDocs(int maxDoc) {
    FixedBitSet set = new FixedBitSet(maxDoc);
    for (int i = 0; i < maxDoc; ++i) {
        if (randomBoolean()) {
            set.set(i);
        }
    }
    // the last doc must be a root doc
    set.set(maxDoc - 1);
    return set;
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
private static FixedBitSet randomInnerDocs(FixedBitSet rootDocs) {
    FixedBitSet innerDocs = new FixedBitSet(rootDocs.length());
    for (int i = 0; i < innerDocs.length(); ++i) {
        if (!rootDocs.get(i) && randomBoolean()) {
            innerDocs.set(i);
        }
    }
    return innerDocs;
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
public void testSingleValuedStrings() throws Exception  {
    final int numDocs = scaledRandomIntBetween(1, 100);
    final BytesRef[] array = new BytesRef[numDocs];
    final FixedBitSet docsWithValue = randomBoolean() ? null : new FixedBitSet(numDocs);
    for (int i = 0; i < array.length; ++i) {
        if (randomBoolean()) {
            array[i] = new BytesRef(RandomStrings.randomAsciiOfLength(random(), 8));
            if (docsWithValue != null) {
                docsWithValue.set(i);
            }
        } else {
            array[i] = new BytesRef();
            if (docsWithValue != null && randomBoolean()) {
                docsWithValue.set(i);
            }
        }
    }
    final BinaryDocValues singleValues = new BinaryDocValues() {
        @Override
        public BytesRef get(int docID) {
            return BytesRef.deepCopyOf(array[docID]);
        }
    };
    final SortedBinaryDocValues multiValues = FieldData.singleton(singleValues, docsWithValue);
    verify(multiValues, numDocs);
    final FixedBitSet rootDocs = randomRootDocs(numDocs);
    final FixedBitSet innerDocs = randomInnerDocs(rootDocs);
    verify(multiValues, numDocs, rootDocs, innerDocs);
}
 

import org.apache.lucene.util.FixedBitSet; //导入方法依赖的package包/类
public void testUnsortedSingleValuedDoubles() throws Exception  {
    final int numDocs = scaledRandomIntBetween(1, 100);
    final double[] array = new double[numDocs];
    final FixedBitSet docsWithValue = randomBoolean() ? null : new FixedBitSet(numDocs);
    for (int i = 0; i < array.length; ++i) {
        if (randomBoolean()) {
            array[i] = randomDouble();
            if (docsWithValue != null) {
                docsWithValue.set(i);
            }
        } else if (docsWithValue != null && randomBoolean()) {
            docsWithValue.set(i);
        }
    }
    final NumericDoubleValues singleValues = new NumericDoubleValues() {
        @Override
        public double get(int docID) {
            return array[docID];
        }
    };
    final SortedNumericDoubleValues singletonValues = FieldData.singleton(singleValues, docsWithValue);
    final MultiValueMode.UnsortedNumericDoubleValues multiValues = new MultiValueMode.UnsortedNumericDoubleValues() {

        @Override
        public int count() {
            return singletonValues.count();
        }

        @Override
        public void setDocument(int doc) {
            singletonValues.setDocument(doc);
        }

        @Override
        public double valueAt(int index) {
            return Math.cos(singletonValues.valueAt(index));
        }
    };
    verify(multiValues, numDocs);
}