import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
AbstractSolrCachingScorer(Weight weight, DocSet in, AtomicReaderContext context, Bits acceptDocs, SolrIndexSearcher searcher)
{
    super(weight);
    this.context = context;
    this.acceptDocs = acceptDocs;
    
    if (in instanceof BitDocSet)
    {
        matches = (BitDocSet) in;
    }
    else
    {
        this.matches = new BitDocSet(new FixedBitSet(searcher.maxDoc()));
        for (DocIterator it = in.iterator(); it.hasNext(); /* */)
        {
            matches.addUnique(it.nextDoc());
        }
    }
    bitSet = matches.getBits();
    
    doc = getBase() - 1;
}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
public static SolrOwnerScorer createOwnerScorer(Weight weight, AtomicReaderContext context, Bits acceptDocs, SolrIndexSearcher searcher, String authority) throws IOException
{
    if (AuthorityType.getAuthorityType(authority) == AuthorityType.USER)
    {
        DocSet ownedDocs = (DocSet) searcher.cacheLookup(CacheConstants.ALFRESCO_OWNERLOOKUP_CACHE, authority);

        if (ownedDocs == null)
        {
            // Cache miss: query the index for docs where the owner matches the authority. 
            ownedDocs = searcher.getDocSet(new TermQuery(new Term(QueryConstants.FIELD_OWNER, authority)));
            searcher.cacheInsert(CacheConstants.ALFRESCO_OWNERLOOKUP_CACHE, authority, ownedDocs);
        }
        return new SolrOwnerScorer(weight, ownedDocs, context, acceptDocs, searcher);
    }
    
    // Return an empty doc set, as the authority isn't a user.
    return new SolrOwnerScorer(weight, new BitDocSet(new FixedBitSet(0)), context, acceptDocs, searcher);
}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
AbstractSolrCachingScorer(Similarity similarity, DocSet in, SolrIndexReader solrIndexReader)
{
    super(similarity);
    if (in instanceof BitDocSet)
    {
        matches = (BitDocSet) in;
    }
    else
    {
        this.matches = new BitDocSet(new OpenBitSet(solrIndexReader.maxDoc()));
        for (DocIterator it = in.iterator(); it.hasNext(); /* */)
        {
            matches.addUnique(it.nextDoc());
        }
    }
    openBitSet = matches.getBits();
    this.solrIndexReader = solrIndexReader;
    doc = solrIndexReader.getBase() - 1;
}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
static void generate(int maxSize, int bitsToSet) {
  bs = new OpenBitSet(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.fastSet(id);
        ids[count++]=id;
      }
    }
  }
  bds = new BitDocSet(bs,bitsToSet);
  hds = new HashDocSet(ids,0,count);
}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
private DocSet computeGroupedDocSet(Query query, ProcessedFilter filter, List<Collector> collectors) throws IOException {
  Command firstCommand = commands.get(0);
  AbstractAllGroupHeadsCollector termAllGroupHeadsCollector =
      TermAllGroupHeadsCollector.create(firstCommand.getKey(), firstCommand.getSortWithinGroup());
  if (collectors.isEmpty()) {
    searchWithTimeLimiter(query, filter, termAllGroupHeadsCollector);
  } else {
    collectors.add(termAllGroupHeadsCollector);
    searchWithTimeLimiter(query, filter, MultiCollector.wrap(collectors.toArray(new Collector[collectors.size()])));
  }

  return new BitDocSet(termAllGroupHeadsCollector.retrieveGroupHeads(searcher.maxDoc()));
}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
public static SolrOwnerSetScorer createOwnerSetScorer(SolrIndexSearcher searcher, Similarity similarity, String authorities, SolrIndexReader reader) throws IOException
{
    // Get hold of solr top level searcher
    // Execute query with caching
    // translate reults to leaf docs
    // build ordered doc list

    BitDocSet authorityOwnedDocs = new BitDocSet(new OpenBitSet(searcher.getReader().maxDoc()));

    HashMap<String, OwnerLookUp> ownerLookUp = (HashMap<String, OwnerLookUp>) searcher.cacheLookup(AlfrescoSolrEventListener.ALFRESCO_CACHE,
            AlfrescoSolrEventListener.KEY_OWNER_LOOKUP);

    String[] auths = authorities.substring(1).split(authorities.substring(0, 1));
    
    for (String current : auths)
    {
        OwnerLookUp lookUp = ownerLookUp.get(current);
        if (lookUp != null)
        {
            ResizeableArrayList<CacheEntry> indexedOderedByOwnerIdThenDoc = (ResizeableArrayList<CacheEntry>) searcher.cacheLookup(AlfrescoSolrEventListener.ALFRESCO_ARRAYLIST_CACHE,
                    AlfrescoSolrEventListener.KEY_DBID_LEAF_PATH_BY_OWNER_ID_THEN_LEAF);
            for (int i = lookUp.getStart(); i < lookUp.getEnd(); i++)
            {
                authorityOwnedDocs.addUnique(indexedOderedByOwnerIdThenDoc.get(i).getLeaf());
            }
        }
    }

    return new SolrOwnerSetScorer(similarity, authorityOwnedDocs, reader);

}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
private boolean shouldElementBeIgnored(long dbId, SolrIndexSearcher solrIndexSearcher, DocSet skippingDocs) throws IOException
{
    boolean result = false;

    if ((skipDescendantAuxDocsForSpecificTypes && !typesForSkippingDescendantAuxDocs.isEmpty())
            || (skipDescendantAuxDocsForSpecificAspects && !aspectsForSkippingDescendantAuxDocs.isEmpty()))
    {
        BooleanQuery query = new BooleanQuery();
        query.add(new TermQuery(new Term(QueryConstants.FIELD_DBID, NumericEncoder.encode(dbId))), Occur.MUST);

        DocSet docSet = solrIndexSearcher.getDocSet(query);

        int index = -1;
        if (docSet instanceof BitDocSet)
        {
            BitDocSet source = (BitDocSet) docSet;
            OpenBitSet openBitSet = source.getBits();
            index = openBitSet.nextSetBit(index + 1);
        }
        else
        {
            DocIterator it = docSet.iterator();
            if (it.hasNext())
            {
                index = it.nextDoc();
            }
        }

        result = (-1 != index) && skippingDocs.exists(index);
    }

    return result;
}
 

import org.apache.solr.search.BitDocSet; //导入依赖的package包/类
/**
 * The set of documents matching the provided 'fq' (filter query). Don't include deleted docs
 * either. If null is returned, then all docs are available.
 */
private Bits computeDocCorpus(SolrQueryRequest req) throws SyntaxError, IOException {
  final String[] corpusFilterQueries = req.getParams().getParams("fq");
  final SolrIndexSearcher searcher = req.getSearcher();
  final Bits docBits;
  if (corpusFilterQueries != null && corpusFilterQueries.length > 0) {
    List<Query> filterQueries = new ArrayList<Query>(corpusFilterQueries.length);
    for (String corpusFilterQuery : corpusFilterQueries) {
      QParser qParser = QParser.getParser(corpusFilterQuery, null, req);
      try {
        filterQueries.add(qParser.parse());
      } catch (SyntaxError e) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e);
      }
    }

    final DocSet docSet = searcher.getDocSet(filterQueries);//hopefully in the cache
    //note: before Solr 4.7 we could call docSet.getBits() but no longer.
    if (docSet instanceof BitDocSet) {
      docBits = ((BitDocSet)docSet).getBits();
    } else {
      docBits = new Bits() {

        @Override
        public boolean get(int index) {
          return docSet.exists(index);
        }

        @Override
        public int length() {
          return searcher.maxDoc();
        }
      };
    }
  } else {
    docBits = searcher.getSlowAtomicReader().getLiveDocs();
  }
  return docBits;
}