public CompoundFileWriter(Directory dir,
    String name) 
{
                                      
      this(dir, name, null);
}

Create the compound stream in the specified file. The file name is the entire name (no extensions are added).

Throws:

NullPointerException - if dir or name is null

 CompoundFileWriter(Directory dir,
    String name,
    SegmentMerger.CheckAbort checkAbort) 
{
        if (dir == null)
            throw new NullPointerException("directory cannot be null");
        if (name == null)
            throw new NullPointerException("name cannot be null");
        this.checkAbort = checkAbort;
        directory = dir;
        fileName = name;
        ids = new HashSet();
        entries = new LinkedList();
}

 public  void addFile(String file) 
{
        if (merged)
            throw new IllegalStateException(
                "Can't add extensions after merge has been called");
        if (file == null)
            throw new NullPointerException(
                "file cannot be null");
        if (! ids.add(file))
            throw new IllegalArgumentException(
                "File " + file + " already added");
        FileEntry entry = new FileEntry();
        entry.file = file;
        entries.add(entry);
}

Add a source stream. file is the string by which the sub-stream will be known in the compound stream.

 public  void close() throws IOException 
{
        if (merged)
            throw new IllegalStateException(
                "Merge already performed");
        if (entries.isEmpty())
            throw new IllegalStateException(
                "No entries to merge have been defined");
        merged = true;
        // open the compound stream
        IndexOutput os = null;
        try {
            os = directory.createOutput(fileName);
            // Write the number of entries
            os.writeVInt(entries.size());
            // Write the directory with all offsets at 0.
            // Remember the positions of directory entries so that we can
            // adjust the offsets later
            Iterator it = entries.iterator();
            while(it.hasNext()) {
                FileEntry fe = (FileEntry) it.next();
                fe.directoryOffset = os.getFilePointer();
                os.writeLong(0);    // for now
                os.writeString(fe.file);
            }
            // Open the files and copy their data into the stream.
            // Remember the locations of each file's data section.
            byte buffer[] = new byte[16384];
            it = entries.iterator();
            while(it.hasNext()) {
                FileEntry fe = (FileEntry) it.next();
                fe.dataOffset = os.getFilePointer();
                copyFile(fe, os, buffer);
            }
            // Write the data offsets into the directory of the compound stream
            it = entries.iterator();
            while(it.hasNext()) {
                FileEntry fe = (FileEntry) it.next();
                os.seek(fe.directoryOffset);
                os.writeLong(fe.dataOffset);
            }
            // Close the output stream. Set the os to null before trying to
            // close so that if an exception occurs during the close, the
            // finally clause below will not attempt to close the stream
            // the second time.
            IndexOutput tmp = os;
            os = null;
            tmp.close();
        } finally {
            if (os != null) try { os.close(); } catch (IOException e) { }
        }
}

Merge files with the extensions added up to now. All files with these extensions are combined sequentially into the compound stream. After successful merge, the source files are deleted.

 public Directory getDirectory() 
{
        return directory;
}

Returns the directory of the compound file.

 public String getName() 
{
        return fileName;
}

Returns the name of the compound file.