FieldsWriter(Directory d,
    String segment,
    FieldInfos fn) throws IOException 
{
            
        fieldInfos = fn;
        fieldsStream = d.createOutput(segment + ".fdt");
        indexStream = d.createOutput(segment + ".fdx");
        doClose = true;
}

 FieldsWriter(IndexOutput fdx,
    IndexOutput fdt,
    FieldInfos fn) throws IOException 
{
        fieldInfos = fn;
        fieldsStream = fdt;
        indexStream = fdx;
        doClose = false;
}

 final  void addDocument(Document doc) throws IOException 
{
        indexStream.writeLong(fieldsStream.getFilePointer());
        int storedCount = 0;
        Iterator fieldIterator = doc.getFields().iterator();
        while (fieldIterator.hasNext()) {
            Fieldable field = (Fieldable) fieldIterator.next();
            if (field.isStored())
                storedCount++;
        }
        fieldsStream.writeVInt(storedCount);
        fieldIterator = doc.getFields().iterator();
        while (fieldIterator.hasNext()) {
            Fieldable field = (Fieldable) fieldIterator.next();
            if (field.isStored())
              writeField(fieldInfos.fieldInfo(field.name()), field);
        }
}

 final  void addRawDocuments(IndexInput stream,
    int[] lengths,
    int numDocs) throws IOException 
{
      long position = fieldsStream.getFilePointer();
      long start = position;
      for(int i=0;i< numDocs;i++) {
        indexStream.writeLong(position);
        position += lengths[i];
      }
      fieldsStream.copyBytes(stream, position-start);
      assert fieldsStream.getFilePointer() == position;
}

Bulk write a contiguous series of documents. The lengths array is the length (in bytes) of each raw document. The stream IndexInput is the fieldsStream from which we should bulk-copy all bytes.

 final  void close() throws IOException 
{
      if (doClose) {
        fieldsStream.close();
        indexStream.close();
      }
}

  void flush() throws IOException 
{
      indexStream.flush();
      fieldsStream.flush();
}

  void flushDocument(int numStoredFields,
    RAMOutputStream buffer) throws IOException 
{
      indexStream.writeLong(fieldsStream.getFilePointer());
      fieldsStream.writeVInt(numStoredFields);
      buffer.writeTo(fieldsStream);
}

 final  void writeField(FieldInfo fi,
    Fieldable field) throws IOException 
{
      // if the field as an instanceof FieldsReader.FieldForMerge, we're in merge mode
      // and field.binaryValue() already returns the compressed value for a field
      // with isCompressed()==true, so we disable compression in that case
      boolean disableCompression = (field instanceof FieldsReader.FieldForMerge);
      fieldsStream.writeVInt(fi.number);
      byte bits = 0;
      if (field.isTokenized())
        bits |= FieldsWriter.FIELD_IS_TOKENIZED;
      if (field.isBinary())
        bits |= FieldsWriter.FIELD_IS_BINARY;
      if (field.isCompressed())
        bits |= FieldsWriter.FIELD_IS_COMPRESSED;
      fieldsStream.writeByte(bits);
      if (field.isCompressed()) {
        // compression is enabled for the current field
        byte[] data = null;
        if (disableCompression) {
          // optimized case for merging, the data
          // is already compressed
          data = field.binaryValue();
        } else {
          // check if it is a binary field
          if (field.isBinary()) {
            data = compress(field.binaryValue());
          }
          else {
            data = compress(field.stringValue().getBytes("UTF-8"));
          }
        }
        final int len = data.length;
        fieldsStream.writeVInt(len);
        fieldsStream.writeBytes(data, len);
      }
      else {
        // compression is disabled for the current field
        if (field.isBinary()) {
          byte[] data = field.binaryValue();
          final int len = data.length;
          fieldsStream.writeVInt(len);
          fieldsStream.writeBytes(data, len);
        }
        else {
          fieldsStream.writeString(field.stringValue());
        }
      }
}