How to use

maxDoc

method

in

org.apache.lucene.index.IndexReader

@Override
public long maxCount()
{
  return reader.maxDoc();
}

  private int maxDoc() throws IOException {
    return searcher.getIndexReader().maxDoc();
  }
}

  private int maxDoc() throws IOException {
    return searcher.getIndexReader().maxDoc();
  }
}

/** Returns the number of deleted documents. */
public final int numDeletedDocs() {
 return maxDoc() - numDocs();
}

  private DocIdSetIterator iterateAllDocs()
  {
    Bits liveDocs = MultiFields.getLiveDocs( reader );
    DocIdSetIterator allDocs = DocIdSetIterator.all( reader.maxDoc() );
    if ( liveDocs == null )
    {
      return allDocs;
    }

    return new FilteredDocIdSetIterator( allDocs )
    {
      @Override
      protected boolean match( int doc )
      {
        return liveDocs.get( doc );
      }
    };
  }
}

private TopFieldDocs searchAfter(FieldDoc after, Query query, int numHits, Sort sort,
  boolean doDocScores, boolean doMaxScore) throws IOException {
 final int limit = Math.max(1, reader.maxDoc());
 if (after != null && after.doc >= limit) {
  throw new IllegalArgumentException("after.doc exceeds the number of documents in the reader: after.doc="
    + after.doc + " limit=" + limit);
 }
 final int cappedNumHits = Math.min(numHits, limit);
 final Sort rewrittenSort = sort.rewrite(this);
 final CollectorManager<TopFieldCollector, TopFieldDocs> manager = new CollectorManager<TopFieldCollector, TopFieldDocs>() {
  @Override
  public TopFieldCollector newCollector() throws IOException {
   final boolean fillFields = true;
   // TODO: don't pay the price for accurate hit counts by default
   return TopFieldCollector.create(rewrittenSort, cappedNumHits, after, fillFields, doDocScores, doMaxScore, true);
  }
  @Override
  public TopFieldDocs reduce(Collection<TopFieldCollector> collectors) throws IOException {
   final TopFieldDocs[] topDocs = new TopFieldDocs[collectors.size()];
   int i = 0;
   for (TopFieldCollector collector : collectors) {
    topDocs[i++] = collector.topDocs();
   }
   return TopDocs.merge(rewrittenSort, 0, cappedNumHits, topDocs, true);
  }
 };
 return search(query, manager);
}

/** Check whether this segment is eligible for caching, regardless of the query. */
private boolean shouldCache(LeafReaderContext context) throws IOException {
 return cacheEntryHasReasonableWorstCaseSize(ReaderUtil.getTopLevelContext(context).reader().maxDoc())
   && leavesToCache.test(context);
}

/** This method may return null if the field does not exist or if it has no terms. */
public static Terms getTerms(IndexReader r, String field) throws IOException {
 final List<LeafReaderContext> leaves = r.leaves();
 if (leaves.size() == 1) {
  return leaves.get(0).reader().terms(field);
 }
 final List<Terms> termsPerLeaf = new ArrayList<>(leaves.size());
 final List<ReaderSlice> slicePerLeaf = new ArrayList<>(leaves.size());
 for (int leafIdx = 0; leafIdx < leaves.size(); leafIdx++) {
  LeafReaderContext ctx = leaves.get(leafIdx);
  Terms subTerms = ctx.reader().terms(field);
  if (subTerms != null) {
   termsPerLeaf.add(subTerms);
   slicePerLeaf.add(new ReaderSlice(ctx.docBase, r.maxDoc(), leafIdx - 1));
  }
 }
 if (termsPerLeaf.size() == 0) {
  return null;
 } else {
  return new MultiTerms(termsPerLeaf.toArray(Terms.EMPTY_ARRAY),
    slicePerLeaf.toArray(ReaderSlice.EMPTY_ARRAY));
 }
}

 private IndexReaderContext build(CompositeReaderContext parent, IndexReader reader, int ord, int docBase) {
  if (reader instanceof LeafReader) {
   final LeafReader ar = (LeafReader) reader;
   final LeafReaderContext atomic = new LeafReaderContext(parent, ar, ord, docBase, leaves.size(), leafDocBase);
   leaves.add(atomic);
   leafDocBase += reader.maxDoc();
   return atomic;
  } else {
   final CompositeReader cr = (CompositeReader) reader;
   final List<? extends IndexReader> sequentialSubReaders = cr.getSequentialSubReaders();
   final List<IndexReaderContext> children = Arrays.asList(new IndexReaderContext[sequentialSubReaders.size()]);
   final CompositeReaderContext newParent;
   if (parent == null) {
    newParent = new CompositeReaderContext(cr, children, leaves);
   } else {
    newParent = new CompositeReaderContext(parent, cr, ord, docBase, children);
   }
   int newDocBase = 0;
   for (int i = 0, c = sequentialSubReaders.size(); i < c; i++) {
    final IndexReader r = sequentialSubReaders.get(i);
    children.set(i, build(newParent, r, i, newDocBase));
    newDocBase += r.maxDoc();
   }
   assert newDocBase == cr.maxDoc();
   return newParent;
  }
 }
}

private static PartitionSearcher createPartitionSearcher( int maxDoc, int partition, int maxSize )
    throws IOException
{
  PartitionSearcher partitionSearcher = mock( PartitionSearcher.class );
  IndexSearcher indexSearcher = mock( IndexSearcher.class );
  IndexReader indexReader = mock( IndexReader.class );
  when(partitionSearcher.getIndexSearcher()).thenReturn( indexSearcher );
  when( indexSearcher.getIndexReader() ).thenReturn( indexReader );
  when( indexReader.maxDoc() ).thenReturn( maxDoc );
  when( indexSearcher.doc( 0 ) ).thenReturn( createDocument( uniqueDocValue( 1, partition, maxSize ) ) );
  when( indexSearcher.doc( 1 ) ).thenReturn( createDocument( uniqueDocValue( 2, partition, maxSize ) ) );
  when( indexSearcher.doc( 2 ) ).thenReturn( createDocument( uniqueDocValue( 3, partition, maxSize ) ) );
  return partitionSearcher;
}

long getMaxEventId(final String partitionName) {
  final List<File> allDirectories = getDirectoryManager().getDirectories(0L, Long.MAX_VALUE, partitionName);
  if (allDirectories.isEmpty()) {
    return -1L;
  }
  Collections.sort(allDirectories, DirectoryUtils.NEWEST_INDEX_FIRST);
  for (final File directory : allDirectories) {
    final EventIndexSearcher searcher;
    try {
      searcher = indexManager.borrowIndexSearcher(directory);
    } catch (final IOException ioe) {
      logger.warn("Unable to read from Index Directory {}. Will assume that the index is incomplete and not consider this index when determining max event ID", directory);
      continue;
    }
    try {
      final IndexReader reader = searcher.getIndexSearcher().getIndexReader();
      final int maxDocId = reader.maxDoc() - 1;
      final Document document = reader.document(maxDocId);
      final long eventId = document.getField(SearchableFields.Identifier.getSearchableFieldName()).numericValue().longValue();
      logger.info("Determined that Max Event ID indexed for Partition {} is approximately {} based on index {}", partitionName, eventId, directory);
      return eventId;
    } catch (final IOException ioe) {
      logger.warn("Unable to search Index Directory {}. Will assume that the index is incomplete and not consider this index when determining max event ID", directory, ioe);
    } finally {
      indexManager.returnIndexSearcher(searcher);
    }
  }
  return -1L;
}

private long innerCount() {
  try {
    final int maxDoc = searcher.getIndexReader().maxDoc();
    if (maxDoc == 0) {
      return 0;
    }
    TotalHitCountCollector collector = new TotalHitCountCollector();
    searcher.search(createQuery(), getFilter(), collector);
    return collector.getTotalHits();
  } catch (IOException e) {
    throw new QueryException(e);
  } catch (IllegalArgumentException e) {
    throw new QueryException(e);
  }
}

private long innerCount() {
  try {
    final int maxDoc = searcher.getIndexReader().maxDoc();
    if (maxDoc == 0) {
      return 0;
    }
    TotalHitCountCollector collector = new TotalHitCountCollector();
    searcher.search(createQuery(), getFilter(), collector);
    return collector.getTotalHits();
  } catch (IOException e) {
    throw new QueryException(e);
  } catch (IllegalArgumentException e) {
    throw new QueryException(e);
  }
}

  starts[i] = ctx.docBase;
 starts[size] = reader.maxDoc();
 return new MultiBits(liveDocs, starts, true);
} else {

 @Override
 protected Object createValue(IndexReader reader, Entry entryKey)
 throws IOException {
  Entry entry = entryKey;
  String field = entry.field;
    if (reader.maxDoc() == reader.docFreq(new Term(field))) {
   return DocIdSet.EMPTY_DOCIDSET;
  }
    OpenBitSet res = new OpenBitSet(reader.maxDoc());
  TermDocs termDocs = reader.termDocs();
  TermEnum termEnum = reader.terms (new Term (field));
  try {
   do {
    Term term = termEnum.term();
    if (term==null || term.field() != field) break;
    termDocs.seek (termEnum);
    while (termDocs.next()) {
     res.fastSet(termDocs.doc());
    }
   } while (termEnum.next());
  } finally {
   termDocs.close();
   termEnum.close();
  }
  res.flip(0, reader.maxDoc());
  return res;
 }
}

 @Override
 public boolean test(LeafReaderContext context) {
  final int maxDoc = context.reader().maxDoc();
  if (maxDoc < minSize) {
   return false;
  }
  final IndexReaderContext topLevelContext = ReaderUtil.getTopLevelContext(context);
  final float sizeRatio = (float) context.reader().maxDoc() / topLevelContext.reader().maxDoc();
  return sizeRatio >= minSizeRatio;
 }
}

public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
  OpenBitSet result = new OpenBitSet(reader.maxDoc());

  @Override
  protected Object createValue(IndexReader reader, Entry entryKey) throws IOException
  {
    String field = StringHelper.intern(entryKey.field);
    final String[] retArray = new String[reader.maxDoc()];
    Collection<IColumn> fcEntries = getFieldCacheEntries(reader, field);
    for (IColumn col : fcEntries)
    {
      if (col instanceof DeletedColumn)
        continue;
      int docId = CassandraUtils.readVInt(col.name());
      String val = ByteBufferUtil.string(col.value());
      retArray[docId] = val;
    }
    return retArray;
  }
}

 /**
  * Returns {@link CollectionStatistics} for a field.
  * 
  * This can be overridden for example, to return a field's statistics
  * across a distributed collection.
  * @lucene.experimental
  */
 public CollectionStatistics collectionStatistics(String field) throws IOException {
  final int docCount;
  final long sumTotalTermFreq;
  final long sumDocFreq;

  assert field != null;
  
  Terms terms = MultiFields.getTerms(reader, field);
  if (terms == null) {
   docCount = 0;
   sumTotalTermFreq = 0;
   sumDocFreq = 0;
  } else {
   docCount = terms.getDocCount();
   sumTotalTermFreq = terms.getSumTotalTermFreq();
   sumDocFreq = terms.getSumDocFreq();
  }

  return new CollectionStatistics(field, reader.maxDoc(), docCount, sumTotalTermFreq, sumDocFreq);
 }
}

public TermWeight(IndexSearcher searcher, boolean needsScores,
  float boost, TermContext termStates) throws IOException {
 super(TermQuery.this);
 if (needsScores && termStates == null) {
  throw new IllegalStateException("termStates are required when scores are needed");
 }
 this.needsScores = needsScores;
 this.termStates = termStates;
 this.similarity = searcher.getSimilarity(needsScores);
 final CollectionStatistics collectionStats;
 final TermStatistics termStats;
 if (needsScores) {
  collectionStats = searcher.collectionStatistics(term.field());
  termStats = searcher.termStatistics(term, termStates);
 } else {
  // we do not need the actual stats, use fake stats with docFreq=maxDoc and ttf=-1
  final int maxDoc = searcher.getIndexReader().maxDoc();
  collectionStats = new CollectionStatistics(term.field(), maxDoc, -1, -1, -1);
  termStats = new TermStatistics(term.bytes(), maxDoc, -1);
 }
  this.stats = similarity.computeWeight(boost, collectionStats, termStats);
}