Java DocsEnum.NO_MORE_DOCS属性代码示例

protected DocsAndPositionsEnum getPosEnum(IndexReader r, int docid, Term t)
		throws IOException {
	List<AtomicReaderContext> leaves = r.getContext().leaves();
	for (AtomicReaderContext context : leaves) {
		AtomicReader reader = context.reader();
		DocsAndPositionsEnum termPositions = reader.termPositionsEnum(t);
		int doc;
		while ((doc = termPositions.nextDoc()) != DocsEnum.NO_MORE_DOCS
				&& doc != docid) {
		}
		if (doc != DocsEnum.NO_MORE_DOCS) {
			return termPositions;
		}
	}
	assertFalse("Expected positions enum for doc " + docid, true);
	return null; // will never come here
}
 

@Override
public boolean score(Collector collector, int max) throws IOException {
  FakeScorer fakeScorer = new FakeScorer();
  collector.setScorer(fakeScorer);
  if (doc == -1) {
    doc = nextDocOutOfOrder();
  }
  while(doc < max) {
    fakeScorer.doc = doc;
    fakeScorer.score = scores[ords[scoreUpto]];
    collector.collect(doc);
    doc = nextDocOutOfOrder();
  }

  return doc != DocsEnum.NO_MORE_DOCS;
}
 

/** Returns docID if found, else -1. */
public int lookup(BytesRef id, long version) throws IOException {
  for(int seg=0;seg<numSegs;seg++) {
    if (((IDVersionSegmentTermsEnum) termsEnums[seg]).seekExact(id, version)) {
      if (VERBOSE) {
        System.out.println("  found in seg=" + termsEnums[seg]);
      }
      docsEnums[seg] = termsEnums[seg].docs(liveDocs[seg], docsEnums[seg], 0);
      int docID = docsEnums[seg].nextDoc();
      if (docID != DocsEnum.NO_MORE_DOCS) {
        lastVersion = ((IDVersionSegmentTermsEnum) termsEnums[seg]).getVersion();
        return docBases[seg] + docID;
      }
      assert hasDeletions;
    }
  }

  return -1;
}
 

@Override
public void getDocumentsWithWordAsSet(String word, IntOpenHashSet documents) {
    DocsEnum docs = null;
    Term term = new Term(fieldName, word);
    try {
        int baseDocId;
        for (int i = 0; i < reader.length; i++) {
            docs = reader[i].termDocsEnum(term);
            baseDocId = contexts[i].docBase;
            if (docs != null) {
                while (docs.nextDoc() != DocsEnum.NO_MORE_DOCS) {
                    documents.add(baseDocId + docs.docID());
                }
            }
        }
    } catch (IOException e) {
        LOGGER.error("Error while requesting documents for word \"" + word + "\".", e);
    }
}
 

@Override
public void getDocumentsWithWord(String word, IntArrayList documents) {
    DocsEnum docs = null;
    Term term = new Term(fieldName, word);
    try {
        int baseDocId;
        for (int i = 0; i < reader.length; i++) {
            docs = reader[i].termDocsEnum(term);
            baseDocId = contexts[i].docBase;
            if (docs != null) {
                while (docs.nextDoc() != DocsEnum.NO_MORE_DOCS) {
                    documents.add(docs.docID() + baseDocId);
                }
            }
        }
    } catch (IOException e) {
        LOGGER.error("Error while requesting documents for word \"" + word + "\".", e);
    }
}
 

private void assertFreqPosAndPayload(Term t, int[] expFreq, int[][] expPos,
		int[][][] expPay, int numAtomicReaders) throws IOException {
	List<AtomicReaderContext> leaves = r.getContext().leaves();
	for (AtomicReaderContext context : leaves) {
		AtomicReader reader = context.reader();
		DocsAndPositionsEnum termPositions = reader.termPositionsEnum(t);
		int docIndex = 0;
		while (termPositions.nextDoc() != DocsEnum.NO_MORE_DOCS) {
			assertEquals("Incorrect doc " + docIndex + " freq",
					expFreq[docIndex], termPositions.freq());
			assertEquals("Incorrect doc " + docIndex + " pos length",
					expPos[docIndex].length, termPositions.freq());
			int posIndex = 0;
			while (posIndex < termPositions.freq()) {
				int position = termPositions.nextPosition();
				assertEquals("Incorrect pos " + posIndex + " in doc "
						+ docIndex, expPos[docIndex][posIndex], position);
				BytesRef payload = termPositions.getPayload();
				int[] expPayload = expPay[docIndex][posIndex];
				String[] payloadDesc = new String[] { "left", "right",
						"depth", "parent" };
				for (int j = 0; j < 4; j++) {
					assertEquals(
							"Incorrect " + payloadDesc[j] + " payload",
							expPayload[j],
							payload.bytes[payload.offset + j]);
				}
				posIndex++;
			}
			docIndex++;
		}
		numAtomicReaders++;
	}
	assertEquals("Expected one atomic reader", 1, numAtomicReaders);
}
 

protected void requestDocumentsWithWord(String word, IntObjectOpenHashMap<IntArrayList[]> positionsInDocs,
        IntIntOpenHashMap docLengths, int wordId, int numberOfWords) {
    DocsAndPositionsEnum docPosEnum = null;
    Term term = new Term(fieldName, word);
    int localDocId, globalDocId, baseDocId;
    IntArrayList positions[];
    try {
        for (int i = 0; i < reader.length; i++) {
            docPosEnum = reader[i].termPositionsEnum(term);
            baseDocId = contexts[i].docBase;
            if (docPosEnum != null) {
                while (docPosEnum.nextDoc() != DocsEnum.NO_MORE_DOCS) {
                    localDocId = docPosEnum.docID();
                    globalDocId = localDocId + baseDocId;
                    // if this is the first word and we found a new document
                    if (!positionsInDocs.containsKey(globalDocId)) {
                        positions = new IntArrayList[numberOfWords];
                        positionsInDocs.put(globalDocId, positions);
                    } else {
                        positions = positionsInDocs.get(globalDocId);
                    }
                    if (positions[wordId] == null) {
                        positions[wordId] = new IntArrayList();
                    }
                    // Go through the positions inside this document
                    for (int p = 0; p < docPosEnum.freq(); ++p) {
                        positions[wordId].add(docPosEnum.nextPosition());
                    }
                    if (!docLengths.containsKey(globalDocId)) {
                        // Get the length of the document
                        docLengths.put(globalDocId, reader[i].document(localDocId).getField(docLengthFieldName)
                                .numericValue().intValue());
                    }
                }
            }
        }
    } catch (IOException e) {
        LOGGER.error("Error while requesting documents for word \"" + word + "\".", e);
    }
}
 

OpenBitSet[] split(AtomicReaderContext readerContext) throws IOException {
  AtomicReader reader = readerContext.reader();
  OpenBitSet[] docSets = new OpenBitSet[ranges.size()];
  for (int i=0; i<docSets.length; i++) {
    docSets[i] = new OpenBitSet(reader.maxDoc());
  }
  Bits liveDocs = reader.getLiveDocs();

  Fields fields = reader.fields();
  Terms terms = fields==null ? null : fields.terms(field.getName());
  TermsEnum termsEnum = terms==null ? null : terms.iterator(null);
  if (termsEnum == null) return docSets;

  BytesRef term = null;
  DocsEnum docsEnum = null;

  for (;;) {
    term = termsEnum.next();
    if (term == null) break;

    // figure out the hash for the term
    // TODO: hook in custom hashes (or store hashes)
    int hash = Hash.murmurhash3_x86_32(term.bytes, term.offset, term.length, 0);

    docsEnum = termsEnum.docs(liveDocs, docsEnum, DocsEnum.FLAG_NONE);
    for (;;) {
      int doc = docsEnum.nextDoc();
      if (doc == DocsEnum.NO_MORE_DOCS) break;
      for (int i=0; i<rangesArr.length; i++) {      // inner-loop: use array here for extra speed.
        if (rangesArr[i].includes(hash)) {
          docSets[i].fastSet(doc);
        }
      }
    }
  }

  return docSets;
}
 

@SuppressWarnings("deprecation")
@Override
   public DocIdSet getDocIdSet(LeafReaderContext context, Bits acceptDocs) throws IOException {
       
   	long startTime = System.currentTimeMillis();
       int max = context.reader().maxDoc();
       
       OpenBitSet  bits = new OpenBitSet(max);
       
       //OpenBitSet filterBits = new OpenBitSet(max);
       //DocIdSet it;
           
       DocsEnum termDocs =null;
       
       String name=null,val=null;    
       //int ct=context.reader().docFreq(new Term("title","testtitle1"));
       
       if (paramMap.size()==1){ 
           
         Iterator iter = paramMap.entrySet().iterator();
         if (iter.hasNext()) {
              Map.Entry entry = (Map.Entry) iter.next();
              name = (String)entry.getKey();
              val = (String)entry.getValue();
         }
           
          termDocs =context.reader().termDocsEnum(new Term(name,val));
       }
       
       if(termDocs == null){
            return null;
       }
           
       while(termDocs.nextDoc() != DocsEnum.NO_MORE_DOCS){
          bits.set(termDocs.docID());
       }

                      
       //}
       long endTime = System.currentTimeMillis();
       dlogger.debug("Filtering offline offers spend time: {}", endTime - startTime);
       return bits;
   }
 

public void getDocAvgTermFreqs() throws IOException
{
	BufferedWriter fileWriter = new BufferedWriter(new FileWriter(resultsFile));
	//Map<Integer,String> idMap = new HashMap<Integer,String>();
	FlagConfig config = FlagConfig.getFlagConfig(new String[] {"-luceneindexpath",luceneIndex});
	LuceneUtils lu = new LuceneUtils(config);
	TermsEnum termEnum = null;
	TermsEnum terms = lu.getTermsForField("contents").iterator(termEnum);
	BytesRef bytes;
	int tc = 0;
	Map<String,TermSum> docStats = new HashMap<String, TermSum>();
	while ((bytes = terms.next()) != null) 
	{
		if (( tc % 10000 == 0 ) || ( tc < 10000 && tc % 1000 == 0 )) {
	          System.out.println("Processed " + tc + " terms ... ");
	        }
		tc++;

		Term term = new Term("contents", bytes);
		//fileWriter.write(term.text()+"\n");
		//String token = term.text();
		int termfreq = lu.getGlobalTermFreq(term);
		DocsEnum docsEnum = lu.getDocsForTerm(term);
        while (docsEnum.nextDoc() != DocsEnum.NO_MORE_DOCS) 
        {
        	String docName = lu.getDoc(docsEnum.docID()).getField(config.docidfield()).stringValue();
        	TermSum stats = docStats.get(docName);
        	if (stats == null)
        		stats = new TermSum();
        	stats.sum += termfreq;
        	stats.terms += 1;
        	docStats.put(docName, stats);
        }
       }
	
	System.out.println("Output results to file");
	for(Map.Entry<String, TermSum> e : docStats.entrySet())
	{
		float avg = e.getValue().sum/(float)e.getValue().terms;
		fileWriter.write(""+e.getKey()+","+avg+"\n");
	}
	fileWriter.close();
}
 

/** Used when base query is highly constraining vs the
 *  drilldowns, or when the docs must be scored at once
 *  (i.e., like BooleanScorer2, not BooleanScorer).  In
 *  this case we just .next() on base and .advance() on
 *  the dim filters. */ 
private void doQueryFirstScoring(Collector collector, DocIdSetIterator[] disis, Collector[] sidewaysCollectors,
                                 Bits[] bits, Collector[] bitsSidewaysCollectors) throws IOException {
  //if (DEBUG) {
  //  System.out.println("  doQueryFirstScoring");
  //}
  int docID = baseScorer.docID();

  nextDoc: while (docID != DocsEnum.NO_MORE_DOCS) {
    Collector failedCollector = null;
    for (int i=0;i<disis.length;i++) {
      // TODO: should we sort this 2nd dimension of
      // docsEnums from most frequent to least?
      DocIdSetIterator disi = disis[i];
      if (disi != null && disi.docID() < docID) {
        disi.advance(docID);
      }
      if (disi == null || disi.docID() > docID) {
        if (failedCollector != null) {
          // More than one dim fails on this document, so
          // it's neither a hit nor a near-miss; move to
          // next doc:
          docID = baseScorer.nextDoc();
          continue nextDoc;
        } else {
          failedCollector = sidewaysCollectors[i];
        }
      }
    }

    // TODO: for the "non-costly Bits" we really should
    // have passed them down as acceptDocs, but
    // unfortunately we cannot distinguish today betwen
    // "bits() is so costly that you should apply it last"
    // from "bits() is so cheap that you should apply it
    // everywhere down low"

    // Fold in Filter Bits last, since they may be costly:
    for(int i=0;i<bits.length;i++) {
      if (bits[i].get(docID) == false) {
        if (failedCollector != null) {
          // More than one dim fails on this document, so
          // it's neither a hit nor a near-miss; move to
          // next doc:
          docID = baseScorer.nextDoc();
          continue nextDoc;
        } else {
          failedCollector = bitsSidewaysCollectors[i];
        }
      }
    }

    collectDocID = docID;

    // TODO: we could score on demand instead since we are
    // daat here:
    collectScore = baseScorer.score();

    if (failedCollector == null) {
      // Hit passed all filters, so it's "real":
      collectHit(collector, sidewaysCollectors, bitsSidewaysCollectors);
    } else {
      // Hit missed exactly one filter:
      collectNearMiss(failedCollector);
    }

    docID = baseScorer.nextDoc();
  }
}