public SegmentInfo(String name,
    int docCount,
    Directory dir) 
{
         // whether doc store files are stored in compound file (*.cfx)
    this.name = name;
    this.docCount = docCount;
    this.dir = dir;
    delGen = NO;
    isCompoundFile = CHECK_DIR;
    preLockless = true;
    hasSingleNormFile = false;
    docStoreOffset = -1;
    docStoreSegment = name;
    docStoreIsCompoundFile = false;
}

 SegmentInfo(Directory dir,
    int format,
    IndexInput input) throws IOException 
{
    this.dir = dir;
    name = input.readString();
    docCount = input.readInt();
    if (format < = SegmentInfos.FORMAT_LOCKLESS) {
      delGen = input.readLong();
      if (format < = SegmentInfos.FORMAT_SHARED_DOC_STORE) {
        docStoreOffset = input.readInt();
        if (docStoreOffset != -1) {
          docStoreSegment = input.readString();
          docStoreIsCompoundFile = (1 == input.readByte());
        } else {
          docStoreSegment = name;
          docStoreIsCompoundFile = false;
        }
      } else {
        docStoreOffset = -1;
        docStoreSegment = name;
        docStoreIsCompoundFile = false;
      }
      if (format < = SegmentInfos.FORMAT_SINGLE_NORM_FILE) {
        hasSingleNormFile = (1 == input.readByte());
      } else {
        hasSingleNormFile = false;
      }
      int numNormGen = input.readInt();
      if (numNormGen == NO) {
        normGen = null;
      } else {
        normGen = new long[numNormGen];
        for(int j=0;j< numNormGen;j++) {
          normGen[j] = input.readLong();
        }
      }
      isCompoundFile = input.readByte();
      preLockless = (isCompoundFile == CHECK_DIR);
    } else {
      delGen = CHECK_DIR;
      normGen = null;
      isCompoundFile = CHECK_DIR;
      preLockless = true;
      hasSingleNormFile = false;
      docStoreOffset = -1;
      docStoreIsCompoundFile = false;
      docStoreSegment = null;
    }
}

Construct a new SegmentInfo instance by reading a previously saved SegmentInfo from input.

Parameters:

dir - directory to load from

format - format of the segments info file

input - input handle to read segment info from

 public SegmentInfo(String name,
    int docCount,
    Directory dir,
    boolean isCompoundFile,
    boolean hasSingleNormFile) 
{
 
    this(name, docCount, dir, isCompoundFile, hasSingleNormFile, -1, null, false);
}

 public SegmentInfo(String name,
    int docCount,
    Directory dir,
    boolean isCompoundFile,
    boolean hasSingleNormFile,
    int docStoreOffset,
    String docStoreSegment,
    boolean docStoreIsCompoundFile) 
{
 
    this(name, docCount, dir);
    this.isCompoundFile = (byte) (isCompoundFile ? YES : NO);
    this.hasSingleNormFile = hasSingleNormFile;
    preLockless = false;
    this.docStoreOffset = docStoreOffset;
    this.docStoreSegment = docStoreSegment;
    this.docStoreIsCompoundFile = docStoreIsCompoundFile;
    assert docStoreOffset == -1 || docStoreSegment != null;
}

  void advanceDelGen() 
{
    // delGen 0 is reserved for pre-LOCKLESS format
    if (delGen == NO) {
      delGen = YES;
    } else {
      delGen++;
    }
    clearFiles();
}

  void advanceNormGen(int fieldIndex) 
{
    if (normGen[fieldIndex] == NO) {
      normGen[fieldIndex] = YES;
    } else {
      normGen[fieldIndex]++;
    }
    clearFiles();
}

Increment the generation count for the norms file for this field.

  void clearDelGen() 
{
    delGen = NO;
    clearFiles();
}

 public Object clone() 
{
    SegmentInfo si = new SegmentInfo(name, docCount, dir);
    si.isCompoundFile = isCompoundFile;
    si.delGen = delGen;
    si.preLockless = preLockless;
    si.hasSingleNormFile = hasSingleNormFile;
    if (normGen != null) {
      si.normGen = (long[]) normGen.clone();
    }
    si.docStoreOffset = docStoreOffset;
    si.docStoreSegment = docStoreSegment;
    si.docStoreIsCompoundFile = docStoreIsCompoundFile;
    return si;
}

 public boolean equals(Object obj) 
{
    SegmentInfo other;
    try {
      other = (SegmentInfo) obj;
    } catch (ClassCastException cce) {
      return false;
    }
    return other.dir == dir && other.name.equals(name);
}

We consider another SegmentInfo instance equal if it has the same dir and same name.

 public List files() throws IOException 
{
    if (files != null) {
      // Already cached:
      return files;
    }
    files = new ArrayList();
    boolean useCompoundFile = getUseCompoundFile();
    if (useCompoundFile) {
      files.add(name + "." + IndexFileNames.COMPOUND_FILE_EXTENSION);
    } else {
      final String[] exts = IndexFileNames.NON_STORE_INDEX_EXTENSIONS;
      for(int i=0;i< exts.length;i++)
        addIfExists(files, name + "." + exts[i]);
    }
    if (docStoreOffset != -1) {
      // We are sharing doc stores (stored fields, term
      // vectors) with other segments
      assert docStoreSegment != null;
      if (docStoreIsCompoundFile) {
        files.add(docStoreSegment + "." + IndexFileNames.COMPOUND_FILE_STORE_EXTENSION);
      } else {
        final String[] exts = IndexFileNames.STORE_INDEX_EXTENSIONS;
        for(int i=0;i< exts.length;i++)
          addIfExists(files, docStoreSegment + "." + exts[i]);
      }
    } else if (!useCompoundFile) {
      // We are not sharing, and, these files were not
      // included in the compound file
      final String[] exts = IndexFileNames.STORE_INDEX_EXTENSIONS;
      for(int i=0;i< exts.length;i++)
        addIfExists(files, name + "." + exts[i]);
    }
    String delFileName = IndexFileNames.fileNameFromGeneration(name, "." + IndexFileNames.DELETES_EXTENSION, delGen);
    if (delFileName != null && (delGen  >= YES || dir.fileExists(delFileName))) {
      files.add(delFileName);
    }
    // Careful logic for norms files    
    if (normGen != null) {
      for(int i=0;i< normGen.length;i++) {
        long gen = normGen[i];
        if (gen  >= YES) {
          // Definitely a separate norm file, with generation:
          files.add(IndexFileNames.fileNameFromGeneration(name, "." + IndexFileNames.SEPARATE_NORMS_EXTENSION + i, gen));
        } else if (NO == gen) {
          // No separate norms but maybe plain norms
          // in the non compound file case:
          if (!hasSingleNormFile && !useCompoundFile) {
            String fileName = name + "." + IndexFileNames.PLAIN_NORMS_EXTENSION + i;
            if (dir.fileExists(fileName)) {
              files.add(fileName);
            }
          }
        } else if (CHECK_DIR == gen) {
          // Pre-2.1: we have to check file existence
          String fileName = null;
          if (useCompoundFile) {
            fileName = name + "." + IndexFileNames.SEPARATE_NORMS_EXTENSION + i;
          } else if (!hasSingleNormFile) {
            fileName = name + "." + IndexFileNames.PLAIN_NORMS_EXTENSION + i;
          }
          if (fileName != null && dir.fileExists(fileName)) {
            files.add(fileName);
          }
        }
      }
    } else if (preLockless || (!hasSingleNormFile && !useCompoundFile)) {
      // Pre-2.1: we have to scan the dir to find all
      // matching _X.sN/_X.fN files for our segment:
      String prefix;
      if (useCompoundFile)
        prefix = name + "." + IndexFileNames.SEPARATE_NORMS_EXTENSION;
      else
        prefix = name + "." + IndexFileNames.PLAIN_NORMS_EXTENSION;
      int prefixLength = prefix.length();
      String[] allFiles = dir.list();
      if (allFiles == null)
        throw new IOException("cannot read directory " + dir + ": list() returned null");
      for(int i=0;i< allFiles.length;i++) {
        String fileName = allFiles[i];
        if (fileName.length()  > prefixLength && Character.isDigit(fileName.charAt(prefixLength)) && fileName.startsWith(prefix)) {
          files.add(fileName);
        }
      }
    }
    return files;
}

 String getDelFileName() 
{
    if (delGen == NO) {
      // In this case we know there is no deletion filename
      // against this segment
      return null;
    } else {
      // If delGen is CHECK_DIR, it's the pre-lockless-commit file format
      return IndexFileNames.fileNameFromGeneration(name, "." + IndexFileNames.DELETES_EXTENSION, delGen); 
    }
}

 boolean getDocStoreIsCompoundFile() 
{
    return docStoreIsCompoundFile;
}

 int getDocStoreOffset() 
{
    return docStoreOffset;
}

 String getDocStoreSegment() 
{
    return docStoreSegment;
}

 String getNormFileName(int number) throws IOException 
{
    String prefix;
    long gen;
    if (normGen == null) {
      gen = CHECK_DIR;
    } else {
      gen = normGen[number];
    }
    if (hasSeparateNorms(number)) {
      // case 1: separate norm
      prefix = ".s";
      return IndexFileNames.fileNameFromGeneration(name, prefix + number, gen);
    }
    if (hasSingleNormFile) {
      // case 2: lockless (or nrm file exists) - single file for all norms 
      prefix = "." + IndexFileNames.NORMS_EXTENSION;
      return IndexFileNames.fileNameFromGeneration(name, prefix, WITHOUT_GEN);
    }
    // case 3: norm file for each field
    prefix = ".f";
    return IndexFileNames.fileNameFromGeneration(name, prefix + number, WITHOUT_GEN);
}

Get the file name for the norms file for this field.

 boolean getUseCompoundFile() throws IOException 
{
    if (isCompoundFile == NO) {
      return false;
    } else if (isCompoundFile == YES) {
      return true;
    } else {
      return dir.fileExists(name + "." + IndexFileNames.COMPOUND_FILE_EXTENSION);
    }
}

Returns true if this segment is stored as a compound file; else, false.

 boolean hasDeletions() throws IOException 
{
    // Cases:
    //
    //   delGen == NO: this means this segment was written
    //     by the LOCKLESS code and for certain does not have
    //     deletions yet
    //
    //   delGen == CHECK_DIR: this means this segment was written by
    //     pre-LOCKLESS code which means we must check
    //     directory to see if .del file exists
    //
    //   delGen  >= YES: this means this segment was written by
    //     the LOCKLESS code and for certain has
    //     deletions
    //
    if (delGen == NO) {
      return false;
    } else if (delGen  >= YES) {
      return true;
    } else {
      return dir.fileExists(getDelFileName());
    }
}

 boolean hasSeparateNorms() throws IOException 
{
    if (normGen == null) {
      if (!preLockless) {
        // This means we were created w/ LOCKLESS code and no
        // norms are written yet:
        return false;
      } else {
        // This means this segment was saved with pre-LOCKLESS
        // code.  So we must fallback to the original
        // directory list check:
        String[] result = dir.list();
        if (result == null)
          throw new IOException("cannot read directory " + dir + ": list() returned null");
        String pattern;
        pattern = name + ".s";
        int patternLength = pattern.length();
        for(int i = 0; i <  result.length; i++){
          if(result[i].startsWith(pattern) && Character.isDigit(result[i].charAt(patternLength)))
            return true;
        }
        return false;
      }
    } else {
      // This means this segment was saved with LOCKLESS
      // code so we first check whether any normGen's are  >= 1
      // (meaning they definitely have separate norms):
      for(int i=0;i< normGen.length;i++) {
        if (normGen[i]  >= YES) {
          return true;
        }
      }
      // Next we look for any == 0.  These cases were
      // pre-LOCKLESS and must be checked in directory:
      for(int i=0;i< normGen.length;i++) {
        if (normGen[i] == CHECK_DIR) {
          if (hasSeparateNorms(i)) {
            return true;
          }
        }
      }
    }
    return false;
}

Returns true if any fields in this segment have separate norms.

 boolean hasSeparateNorms(int fieldNumber) throws IOException 
{
    if ((normGen == null && preLockless) || (normGen != null && normGen[fieldNumber] == CHECK_DIR)) {
      // Must fallback to directory file exists check:
      String fileName = name + ".s" + fieldNumber;
      return dir.fileExists(fileName);
    } else if (normGen == null || normGen[fieldNumber] == NO) {
      return false;
    } else {
      return true;
    }
}

Returns true if this field for this segment has saved a separate norms file (__N.sX).

 public int hashCode() 
{
    return dir.hashCode() + name.hashCode();
}

  void reset(SegmentInfo src) 
{
    clearFiles();
    name = src.name;
    docCount = src.docCount;
    dir = src.dir;
    preLockless = src.preLockless;
    delGen = src.delGen;
    docStoreOffset = src.docStoreOffset;
    docStoreIsCompoundFile = src.docStoreIsCompoundFile;
    if (src.normGen == null) {
      normGen = null;
    } else {
      normGen = new long[src.normGen.length];
      System.arraycopy(src.normGen, 0, normGen, 0, src.normGen.length);
    }
    isCompoundFile = src.isCompoundFile;
    hasSingleNormFile = src.hasSingleNormFile;
}

Copy everything from src SegmentInfo into our instance.

 public String segString(Directory dir) 
{
    String cfs;
    try {
      if (getUseCompoundFile())
        cfs = "c";
      else
        cfs = "C";
    } catch (IOException ioe) {
      cfs = "?";
    }
    String docStore;
    if (docStoreOffset != -1)
      docStore = "- >" + docStoreSegment;
    else
      docStore = "";
    return name + ":" +
      cfs +
      (this.dir == dir ? "" : "x") +
      docCount + docStore;
}

Used for debugging

  void setDocStoreIsCompoundFile(boolean v) 
{
    docStoreIsCompoundFile = v;
    clearFiles();
}

  void setDocStoreOffset(int offset) 
{
    docStoreOffset = offset;
    clearFiles();
}

  void setNumFields(int numFields) 
{
    if (normGen == null) {
      // normGen is null if we loaded a pre-2.1 segment
      // file, or, if this segments file hasn't had any
      // norms set against it yet:
      normGen = new long[numFields];
      if (preLockless) {
        // Do nothing: thus leaving normGen[k]==CHECK_DIR (==0), so that later we know  
        // we have to check filesystem for norm files, because this is prelockless.
      } else {
        // This is a FORMAT_LOCKLESS segment, which means
        // there are no separate norms:
        for(int i=0;i< numFields;i++) {
          normGen[i] = NO;
        }
      }
    }
}

  void setUseCompoundFile(boolean isCompoundFile) 
{
    if (isCompoundFile) {
      this.isCompoundFile = YES;
    } else {
      this.isCompoundFile = NO;
    }
    clearFiles();
}

Mark whether this segment is stored as a compound file.

 long sizeInBytes() throws IOException 
{
    if (sizeInBytes == -1) {
      List files = files();
      final int size = files.size();
      sizeInBytes = 0;
      for(int i=0;i< size;i++) {
        final String fileName = (String) files.get(i);
        // We don't count bytes used by a shared doc store
        // against this segment:
        if (docStoreOffset == -1 || !IndexFileNames.isDocStoreFile(fileName))
          sizeInBytes += dir.fileLength(fileName);
      }
    }
    return sizeInBytes;
}

Returns total size in bytes of all of files used by this segment.

  void write(IndexOutput output) throws IOException 
{
    output.writeString(name);
    output.writeInt(docCount);
    output.writeLong(delGen);
    output.writeInt(docStoreOffset);
    if (docStoreOffset != -1) {
      output.writeString(docStoreSegment);
      output.writeByte((byte) (docStoreIsCompoundFile ? 1:0));
    }
    output.writeByte((byte) (hasSingleNormFile ? 1:0));
    if (normGen == null) {
      output.writeInt(NO);
    } else {
      output.writeInt(normGen.length);
      for(int j = 0; j <  normGen.length; j++) {
        output.writeLong(normGen[j]);
      }
    }
    output.writeByte(isCompoundFile);
}

Save this segment's info.