FS/FS_Info.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_Info.h ( FS Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __FS_Info__
#define __FS_Info__

#include "FS_API.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_Assert.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_String.h>
#include <UT/UT_StringArray.h>

class FS_InfoHelper;
class FS_IndexFile;

enum FS_FileAccessMode
{
    FS_READ     = 0x01,
    FS_WRITE    = 0x02,
    FS_EXECUTE  = 0x04
};

/// Helper class for encapsulating file information
class FS_API FS_Stat
{
public:
    FS_Stat(time_t f_mtime = 0, int64 fsize = 0, bool is_dir = false, bool is_shortcut = false)
        : myModTime(f_mtime), mySize(fsize), myDirectory(is_dir), myShortcut(is_shortcut)
    {
    }

    // This method is used to maintain the stat information when a
    // sequence of files is being collapsed into one entry.
    void updateSequenceStat(const FS_Stat &entry)
    {
        // The modification time for a sequence is the most current
        // of the modification times of its entries.
        if (myModTime < entry.myModTime)
            myModTime = entry.myModTime;

        // Size for a sequence should be the sum of all files
        mySize += entry.mySize;
    }

    bool operator==(const FS_Stat &s)
    {
        return (myModTime == s.myModTime
                && mySize == s.mySize
                && myDirectory == s.myDirectory
                && myShortcut == s.myShortcut);
    }

    time_t      myModTime;
    int64       mySize;
    bool        myDirectory:1,
                myShortcut:1;   // only on Windows
};

/// Class for retrieving file information
class FS_API FS_Info
{
public:
             /// Use this constructor to create a new info object. The
             /// specified file is not actually opened or accessed until one of
             /// the information gathering methods is called.
             FS_Info(const char *source);

    virtual ~FS_Info();

                         /// This function returns whether or not the current
                         /// user has rights to access the file in the given
                         /// mode. The mode parameter can be any of FS_READ,
                         /// FS_WRITE, or FS_EXECUTE. You can also or these
                         /// values together to check multiple access types
                         /// simultaneously. If the mode value is 0, the
                         /// function returns @c true if the file exists.
    bool                 hasAccess(int mode = 0) const;

                         /// Returns if the path is a directory
    bool                 getIsDirectory() const;

                         /// Returns the modification time of the file. The
                         /// returned value can be cast directly to a time_t
                         /// value, as defined in the standard C library.
    int                  getModTime() const;

                         /// Returns the file size
    int64                getFileDataSize() const;

                         /// Does bulk load of files and directories from the
                         /// source. If the source specified in the constructor
                         /// is a directory rather than an individual file,
                         /// this method will return a listing of all files and
                         /// directories contained in that directory.
    bool                 getContents(UT_StringArray &contents,
                                     UT_StringArray *dirs = 0,
                                     UT_RefArray<FS_Stat> *stats = 0,
                                     UT_RefArray<FS_Stat> *dir_stats = 0
                                     );

    bool                 fileExists() const;
    bool                 canReadFile() const;
    bool                 canWriteFile() const;
    bool                 canWriteDirectory() const;
    bool                 canDeleteFile() const;
    static char          getNextSepChar(const char *source);
    static char          getPrevSepChar(const char *source);

    static bool          getContentsFromIndexFile(FS_IndexFile &index,
                                                  UT_StringArray &contents,
                                                  UT_StringArray *dirs);

    static bool          statFile(const char *source,
                                  const char *filename,
                                  FS_Stat *fstat);

    // Functions for adding and removing helpers.
    static void          addInfoHelper(FS_InfoHelper *helper);
    static void          removeInfoHelper(FS_InfoHelper *helper);

private:
    static UT_PtrArray<FS_InfoHelper *>         &getHelpers();

    UT_String                                    myPath;
    UT_String                                    mySection;
};

class FS_API FS_InfoHelper
{
public:
             FS_InfoHelper()
             { FS_Info::addInfoHelper(this); }
    virtual ~FS_InfoHelper()
             { FS_Info::removeInfoHelper(this); }

    virtual bool         canHandle(const char *source) = 0;
    virtual bool         hasAccess(const char *source, int mode) = 0;
    virtual bool         getIsDirectory(const char *source) = 0;
    virtual int          getModTime(const char *source) = 0;
    virtual int64        getSize (const char *source) = 0;
    virtual bool         getContents(const char *source,
                                     UT_StringArray &contents,
                                     UT_StringArray *dirs) = 0;
    virtual char         getNextSepChar(const char * /*source*/)
                         { return '/'; }
    virtual char         getPrevSepChar(const char * /*source*/)
                         { return '/'; }
};

#endif

---