FieldInfos() 
{

}

 FieldInfos(Directory d,
    String name) throws IOException 
{
    IndexInput input = d.openInput(name);
    try {
      read(input);
    } finally {
      input.close();
    }
}

Construct a FieldInfos object using the directory and the name of the file IndexInput

Parameters:

d - The directory to open the IndexInput from

name - The name of the file to open the IndexInput from in the Directory

Throws:

IOException -

 public  void add(Document doc) 
{
    List fields = doc.getFields();
    Iterator fieldIterator = fields.iterator();
    while (fieldIterator.hasNext()) {
      Fieldable field = (Fieldable) fieldIterator.next();
      add(field.name(), field.isIndexed(), field.isTermVectorStored(), field.isStorePositionWithTermVector(),
              field.isStoreOffsetWithTermVector(), field.getOmitNorms());
    }
}

Adds field info for a Document.

 public  void add(Collection names,
    boolean isIndexed) 
{
    Iterator i = names.iterator();
    while (i.hasNext()) {
      add((String)i.next(), isIndexed);
    }
}

Assumes the fields are not storing term vectors.

 public  void add(String name,
    boolean isIndexed) 
{
    add(name, isIndexed, false, false, false, false);
}

Calls 5 parameter add with false for all TermVector parameters.

 public  void add(String name,
    boolean isIndexed,
    boolean storeTermVector) 
{
    add(name, isIndexed, storeTermVector, false, false, false);
}

Calls 5 parameter add with false for term vector positions and offsets.

 public  void add(String name,
    boolean isIndexed,
    boolean storeTermVector,
    boolean storePositionWithTermVector,
    boolean storeOffsetWithTermVector) 
{
    add(name, isIndexed, storeTermVector, storePositionWithTermVector, storeOffsetWithTermVector, false);
}

If the field is not yet known, adds it. If it is known, checks to make sure that the isIndexed flag is the same as was given previously for this field. If not - marks it as being indexed. Same goes for the TermVector parameters.

 public  void add(String name,
    boolean isIndexed,
    boolean storeTermVector,
    boolean storePositionWithTermVector,
    boolean storeOffsetWithTermVector,
    boolean omitNorms) 
{
    add(name, isIndexed, storeTermVector, storePositionWithTermVector,
        storeOffsetWithTermVector, omitNorms, false);
}

If the field is not yet known, adds it. If it is known, checks to make sure that the isIndexed flag is the same as was given previously for this field. If not - marks it as being indexed. Same goes for the TermVector parameters.

 public FieldInfo add(String name,
    boolean isIndexed,
    boolean storeTermVector,
    boolean storePositionWithTermVector,
    boolean storeOffsetWithTermVector,
    boolean omitNorms,
    boolean storePayloads) 
{
    FieldInfo fi = fieldInfo(name);
    if (fi == null) {
      return addInternal(name, isIndexed, storeTermVector, storePositionWithTermVector, storeOffsetWithTermVector, omitNorms, storePayloads);
    } else {
      if (fi.isIndexed != isIndexed) {
        fi.isIndexed = true;                      // once indexed, always index
      }
      if (fi.storeTermVector != storeTermVector) {
        fi.storeTermVector = true;                // once vector, always vector
      }
      if (fi.storePositionWithTermVector != storePositionWithTermVector) {
        fi.storePositionWithTermVector = true;                // once vector, always vector
      }
      if (fi.storeOffsetWithTermVector != storeOffsetWithTermVector) {
        fi.storeOffsetWithTermVector = true;                // once vector, always vector
      }
      if (fi.omitNorms != omitNorms) {
        fi.omitNorms = false;                // once norms are stored, always store
      }
      if (fi.storePayloads != storePayloads) {
        fi.storePayloads = true;
      }
    }
    return fi;
}

If the field is not yet known, adds it. If it is known, checks to make sure that the isIndexed flag is the same as was given previously for this field. If not - marks it as being indexed. Same goes for the TermVector parameters.

 public  void addIndexed(Collection names,
    boolean storeTermVectors,
    boolean storePositionWithTermVector,
    boolean storeOffsetWithTermVector) 
{
    Iterator i = names.iterator();
    while (i.hasNext()) {
      add((String)i.next(), true, storeTermVectors, storePositionWithTermVector, storeOffsetWithTermVector);
    }
}

Add fields that are indexed. Whether they have termvectors has to be specified.

 public Object clone() 
{
    FieldInfos fis = new FieldInfos();
    final int numField = byNumber.size();
    for(int i=0;i< numField;i++) {
      FieldInfo fi = (FieldInfo) ((FieldInfo) byNumber.get(i)).clone();
      fis.byNumber.add(fi);
      fis.byName.put(fi.name, fi);
    }
    return fis;
}

Returns a deep clone of this FieldInfos instance.

 public FieldInfo fieldInfo(String fieldName) 
{
    return (FieldInfo) byName.get(fieldName);
}

 public FieldInfo fieldInfo(int fieldNumber) 
{
	return (fieldNumber  >= 0) ? (FieldInfo) byNumber.get(fieldNumber) : null;
}

Return the fieldinfo object referenced by the fieldNumber.

 public String fieldName(int fieldNumber) 
{
	FieldInfo fi = fieldInfo(fieldNumber);
	return (fi != null) ? fi.name : "";
}

Return the fieldName identified by its number.

 public int fieldNumber(String fieldName) 
{
    FieldInfo fi = fieldInfo(fieldName);
    return (fi != null) ? fi.number : -1;
}

 public boolean hasVectors() 
{
    boolean hasVectors = false;
    for (int i = 0; i <  size(); i++) {
      if (fieldInfo(i).storeTermVector) {
        hasVectors = true;
        break;
      }
    }
    return hasVectors;
}

 public int size() 
{
    return byNumber.size();
}

 public  void write(IndexOutput output) throws IOException 
{
    output.writeVInt(size());
    for (int i = 0; i <  size(); i++) {
      FieldInfo fi = fieldInfo(i);
      byte bits = 0x0;
      if (fi.isIndexed) bits |= IS_INDEXED;
      if (fi.storeTermVector) bits |= STORE_TERMVECTOR;
      if (fi.storePositionWithTermVector) bits |= STORE_POSITIONS_WITH_TERMVECTOR;
      if (fi.storeOffsetWithTermVector) bits |= STORE_OFFSET_WITH_TERMVECTOR;
      if (fi.omitNorms) bits |= OMIT_NORMS;
      if (fi.storePayloads) bits |= STORE_PAYLOADS;
      output.writeString(fi.name);
      output.writeByte(bits);
    }
}

 public  void write(Directory d,
    String name) throws IOException 
{
    IndexOutput output = d.createOutput(name);
    try {
      write(output);
    } finally {
      output.close();
    }
}