hasPayloads = fieldInfo.hasPayloads();

      BytesRef term;

      DocsEnum docsEnum = null;

      final TermsEnum termsEnum = termsIn.iterator(null);

      int termOffset = 0;

      final IntArrayWriter scratch = new IntArrayWriter();

      // Used for payloads, if any:

      final RAMOutputStream ros = new RAMOutputStream();

      // if (DEBUG) {

      //   System.out.println("\nLOAD terms seg=" + state.segmentInfo.name + " field=" + field + " hasOffsets=" + hasOffsets + " hasFreq=" + hasFreq + " hasPos=" + hasPos + " hasPayloads=" + hasPayloads);

      // }

      while ((term = termsEnum.next()) != null) {

        final int docFreq = termsEnum.docFreq();

        final long totalTermFreq = termsEnum.totalTermFreq();

        // if (DEBUG) {

        //   System.out.println("  term=" + term.utf8ToString());

        // }

        termOffsets[count] = termOffset;

        if (termBytes.length < (termOffset + term.length)) {

          termBytes = ArrayUtil.grow(termBytes, termOffset + term.length);

        }

        System.arraycopy(term.bytes, term.offset, termBytes, termOffset, term.length);

        termOffset += term.length;

        termOffsets[count+1] = termOffset;

        if (hasPos) {

          docsAndPositionsEnum = termsEnum.docsAndPositions(null, docsAndPositionsEnum);

        } else {

          docsEnum = termsEnum.docs(null, docsEnum);

        }

        final TermAndSkip ent;

        final DocsEnum docsEnum2;

        if (hasPos) {

          docsEnum2 = docsAndPositionsEnum;

        } else {

          docsEnum2 = docsEnum;

        }

        int docID;

        if (docFreq <= lowFreqCutoff) {

          ros.reset();

          // Pack postings for low-freq terms into a single int[]:

          while ((docID = docsEnum2.nextDoc()) != DocsEnum.NO_MORE_DOCS) {

            scratch.add(docID);

            if (hasFreq) {

              final int freq = docsEnum2.freq();

              scratch.add(freq);

              if (hasPos) {

                for(int pos=0;pos<freq;pos++) {

                  if (hasOffsets) {

                  }

                  if (hasPayloads) {

                    if (payload != null) {

                      scratch.add(payload.length);

                      ros.writeBytes(payload.bytes, payload.offset, payload.length);

                    } else {

                      scratch.add(0);

                    }

                  }

                }

              }

            }

          }

          final byte[] payloads;

          if (hasPayloads) {

            payloads = new byte[(int) ros.getFilePointer()];

            ros.writeTo(payloads, 0);

          } else {

            payloads = null;

          }

          final int[] postings = scratch.get();

       

          ent = new LowFreqTerm(postings, payloads, docFreq, (int) totalTermFreq);

        } else {

          final int[] docs = new int[docFreq];

          final int[] freqs;

          final int[][] positions;

          final byte[][][] payloads;

          if (hasFreq) {

            freqs = new int[docFreq];

            if (hasPos) {

              positions = new int[docFreq][];

              if (hasPayloads) {

                payloads = new byte[docFreq][][];

              } else {

                payloads = null;

              }

            } else {

              positions = null;

              payloads = null;

            }

          } else {

            freqs = null;

            positions = null;

            payloads = null;

          }

          // Use separate int[] for the postings for high-freq

          // terms:

          int upto = 0;

          while ((docID = docsEnum2.nextDoc()) != DocsEnum.NO_MORE_DOCS) {

            docs[upto] = docID;

            if (hasFreq) {

              final int freq = docsEnum2.freq();

              freqs[upto] = freq;

              if (hasPos) {

                final int mult;

                if (hasOffsets) {

                  mult = 3;

                } else {

                  mult = 1;

                }

                if (hasPayloads) {

                  payloads[upto] = new byte[freq][];

                }

                positions[upto] = new int[mult*freq];

                int posUpto = 0;

                for(int pos=0;pos<freq;pos++) {

                  if (hasPayloads) {

                    if (payload != null) {

                      byte[] payloadBytes = new byte[payload.length];

                      System.arraycopy(payload.bytes, payload.offset, payloadBytes, 0, payload.length);

                      payloads[upto][pos] = payloadBytes;

                    }

                  }

                  posUpto++;

                  if (hasOffsets) {

                  }

                }

              }

            }

  @Test

  public void testDocsAndPositionsEnum() throws Exception {

    TermsEnum termsEnum = reader.terms(DOC_POSITIONS_FIELD).iterator(null);

    assertEquals(SeekStatus.FOUND, termsEnum.seekCeil(new BytesRef(DOC_POSITIONS_TERM)));

    int doc;

   

    // test nextDoc()

      assertEquals("incorrect freq for doc=" + doc, sortedValues[doc].intValue() / 10 + 1, freq);

      for (int i = 0; i < freq; i++) {

        if (!doesntSupportOffsets.contains(TestUtil.getPostingsFormat(DOC_POSITIONS_FIELD))) {

        }

      }

    }

   

    // test advance()

    sortedPositions = termsEnum.docsAndPositions(null, reuse);

    if (sortedPositions instanceof SortingDocsAndPositionsEnum) {

      assertTrue(((SortingDocsAndPositionsEnum) sortedPositions).reused(reuse)); // make sure reuse worked

    }

    doc = 0;

      String docTerm = term.utf8ToString();

      if (matchedTokens.contains(docTerm) || docTerm.startsWith(prefixToken)) {

        // use the first occurrence of the term

        if (p < position) {

          position = p;

        }

      }

    }

      assertNotNull(tvs);

      assertEquals(2, tvs.size());

      TermsEnum tvsEnum = tvs.iterator(null);

      assertEquals(new BytesRef("abc"), tvsEnum.next());

      if (field.equals("tv")) {

        assertNull(dpEnum);

      } else {

        assertNotNull(dpEnum);

      }

    assertEquals(1, vector.size());

    TermsEnum termsEnum = vector.iterator(null);

    termsEnum.next();

    assertEquals(2, termsEnum.totalTermFreq());

    r.close();

    dir.close();

  }

    assertEquals(1, reader.docFreq(new Term("content", "another")));

    // Make sure position is still incremented when

    // massive term is skipped:

                                                                MultiFields.getLiveDocs(reader),

                                                                "content",

                                                                new BytesRef("another"));

    // Make sure the doc that has the massive term is in

    // the index:

    assertEquals("document with wicked long term should is not in the index!", 2, reader.numDocs());

          case 2: posFlags = DocsAndPositionsEnum.FLAG_PAYLOADS; break;

          default: posFlags = DocsAndPositionsEnum.FLAG_OFFSETS | DocsAndPositionsEnum.FLAG_PAYLOADS; break;

        }

        // TODO: cast to DocsAndPositionsEnum?

        if (docsAndPositions != null) {

          return docsAndPositions;

        }

      }

      flags |= DocsEnum.FLAG_FREQS;

   

    // it's ok to use MultiFields because we only iterate on one posting list.

    // breaking it to loop over the leaves() only complicates code for no

    // apparent gain.

        Consts.FIELD_PAYLOADS, Consts.PAYLOAD_PARENT_BYTES_REF,

        DocsAndPositionsEnum.FLAG_PAYLOADS);

    // shouldn't really happen, if it does, something's wrong

      throw new CorruptIndexException("Missing parent data for category " + first);

    }

   

    int num = reader.maxDoc();

    for (int i = first; i < num; i++) {

          throw new CorruptIndexException("Missing parent data for category " + i);

        }

       

       

          if (i + 1 < num) {

            throw new CorruptIndexException("Missing parent data for category "+ (i + 1));

          }

          break;

        }

    }

    @Override

    public DocsAndPositionsEnum docsAndPositions(Bits liveDocs, DocsAndPositionsEnum reuse, final int flags) throws IOException {

      final SortingDocsAndPositionsEnum wrapReuse;

      if (reuse != null && reuse instanceof SortingDocsAndPositionsEnum) {

        // if we're asked to reuse the given DocsEnum and it is Sorting, return

        // the wrapped one, since some Codecs expect it.

        wrapReuse = (SortingDocsAndPositionsEnum) reuse;

        inReuse = wrapReuse.getWrapped();

      } else {

        wrapReuse = null;

        inReuse = reuse;

      }

      if (inDocsAndPositions == null) {

        return null;

      }

      // we ignore the fact that offsets may be stored but not asked for,

  private Map<Integer,String> highlightField(String field, String contents[], BreakIterator bi, BytesRef terms[], int[] docids, List<AtomicReaderContext> leaves, int maxPassages) throws IOException { 

    Map<Integer,String> highlights = new HashMap<Integer,String>();

   

    // reuse in the real sense... for docs in same segment we just advance our old enum

    TermsEnum termsEnum = null;

    int lastLeaf = -1;

    PassageFormatter fieldFormatter = getFormatter(field);

    if (fieldFormatter == null) {