FS/FS_IndexFile.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        FS_IndexFile.h ( FS Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __FS_IndexFile__
#define __FS_IndexFile__

#include "FS_API.h"
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_SymbolTable.h>
#include "FS_Reader.h"

class UT_Options;
class FS_WriteFilterFactory;
class FS_IStreamFilterFactory;
class UT_OStrStream;

#define FS_SECTION_SEPARATOR            '?'
#define FS_SECTION_SEPARATOR_STRING     "?"

// This class implements a file that contains several sections that can be found
// at certain offsets of a main file.
class FS_API FS_IndexFile
{
public:
             FS_IndexFile();
             FS_IndexFile(FS_Reader *reader);
             FS_IndexFile(const char *source);
    virtual ~FS_IndexFile();

    // Some basic operations on sections (add, remove, modify).
    // These functions don't affect the source file. The changes
    // are only evident when we call writeFile.
    bool         hasSection(const char *section) const;
    int          getSectionModTime(const char *section) const;
    int          getSectionDataSize(const char *section) const;
    void         readSection(const char *section,
                             char *buffer) const;
    bool         readOptionsSection(const char *section,
                                    UT_Options &options) const;
    void         addSection(const char *section,
                            const char *filename);
    void         addSection(const char *section,
                            UT_OStrStream &os,
                            int modtime = -1);
    void         addSection(const char *section,
                            const char *buffer,
                            int len, int modtime = -1);
    void         addSection(const char *section, const FS_IndexFile &file);
    void         modifySection(const char *section,
                               const char *buffer,
                               int len, int modtime = -1);
    void         removeSection(const char *section);
    void         mergeIndexFile(const FS_IndexFile &file, bool overwrite);

    // Change the ordering of some sections. This is basically a book-keeping
    // change, and only affects things when this index file is then saved.
    void         moveSections(int first, int last, int offset);

    // Get the modification time for the index file as a whole.
    int          getModTime() const;

    // Get the size of the whole index file
    int          getFileDataSize() const;

    // Sets the stream filters used for processing the data when it is read
    // in or written out.
    void         setFilters(FS_WriteFilterFactory *encrypt_factory,
                            FS_IStreamFilterFactory *decrypt_factory);

    // Gets the decryption and encryption filter factories.
    FS_WriteFilterFactory       *getEncryptionFilter() const;
    FS_IStreamFilterFactory     *getDecryptionFilter() const;

    // Get an FS_Reader for reading a section of the index.
    FS_Reader           *getSectionReader(const char *section) const;

    // These utility functions should only be used by FS_ReaderHelpers
    FS_ReaderStream     *getSectionStream(const char *section) const;
    FS_ReaderStream     *getStreamCopy() const;

    // Simple access functions to find out about our sections.
    int                  getNumSections() const;
    const char          *getSectionName(int index) const;

    // Access our source file name (which may be empty).
    const UT_String     &getSourceFile() const;

    // Access functions for our description string.
    const UT_String     &getDescription() const;
    void                 setDescription(const char *description);

    // If we are going to be written to a strstream, this function returns
    // a sensible guess about the buffer size that should be allocated.
    int                  guessStreamSize() const;

    // Write us out to a stream (with all modifications).
    // Note: Don't write out an index file to the same file it was loaded
    // from, since writing implicitly reads the file. Instead, write it to a
    // separate file and then copy it over. This will also require this index
    // file to be reloaded.
    virtual void         writeFile(ostream &os);

    // This functions are for expanding and collapsing an index file,
    // much like hexpand and hcollapse do for cpio archives.
    virtual bool         expandToDirectory(const char *destdir);
    virtual bool         collapseFromDirectory(const char *srcdir);

    // Get the current time, used to set the section modification time.
    static int           getCurrentTime();

protected:
    void                 setModified();

private:
    class FS_API FS_Section
    {
        public:
            FS_Section() 
                :   myDataSize(0), mySectionSize(0), myOffset(0), myModTime(0), 
                    mySection(0) { }
            ~FS_Section() { if( mySection ) delete []mySection; }

            const char  *getName() const            { return myName; }
            void         setName(const char *name)  { myName.harden(name); }
            void         adoptName(char *name)      { myName.adopt(name); }
            void         adoptName(UT_String &name) { myName.adopt(name); }
            int          getDataSize() const        { return myDataSize; }
            void         setDataSize(int length)    { myDataSize = length; }
            int          getSectionSize() const     { return mySectionSize; }
            void         setSectionSize(int length) { mySectionSize = length; }
            // Negative offset means that data is in memory
            int          getOffset() const          { return myOffset; }
            void         setOffset(int offset)      { myOffset = offset; }
            int          getModTime() const         { return myModTime; }
            void         setModTime(int modtime)    { myModTime = modtime; }
            char        *getSectionBytes() const    { return mySection; }
            void         setSectionBytes(const char *data)
                         {
                             if( mySection ) delete []mySection;
                             mySection = new char[mySectionSize];
                             memcpy(mySection, data, mySectionSize);
                         }
            void         stealData(char *data)
                         {
                             if( mySection ) delete []mySection;
                             mySection = data;
                         }

        private:
            UT_String    myName;
            int          myOffset;
            int          myModTime;
            int          myDataSize;
            int          mySectionSize;
            char        *mySection;
    };

    typedef UT_PtrArray<FS_Section *> FS_SectionArray;

    // Functions for opening and closing our stream.
    void                 openStream() const;
    void                 closeStream() const;

    // Helper functions for reading and writing ourselves to a directory.
    void                 makeValidFileName(UT_String &filename);
    bool                 writeSectionListFile(const char *sectionfile);

    // Writes out a section to the output stream. If the filter factory has been
    // set, the filter will be applied to the section data before it is written
    // out.
    void                 writeSection(int section_idx, ostream &os);

    // Read in our index and use it to create our section data structures.
    void                 readIndex();

    // Obtains a size of the i-th section after it has been filtered (if at all)
    int                  getWriteFilteredSectionSize( int index ) const;

    // Recalculates the data sizes of our sections when the read filter is set.
    void                 recalculateFilteredSectionSizes();

    // Data:
    mutable FS_Reader           *myReader;
    FS_SectionArray              mySections;
    UT_SymbolTable               mySectionTable;
    UT_String                    myDescription;
    UT_String                    mySourceFile;
    FS_WriteFilterFactory       *myWriteFilter;
    FS_IStreamFilterFactory     *myReadFilter;
    int                          myModTime;
    int                          mySize;
    int                          myStreamStart;
    bool                         myModified;
};

#endif

---