vfsnode.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vfsnode_h
#define vfsnode_h

#include "vstring.h"

class VFSNodeInfo {
    public:

        VFSNodeInfo();
        ~VFSNodeInfo() {}

        Vs64    mCreationDate;      // a VInstant offset value
        Vs64    mModificationDate;  // a VInstant offset value
        VFSize  mFileSize;
        bool    mIsFile;
        bool    mIsDirectory;
        int     mErrNo; // the value of errno if call failed, 0 otherwise
};


class VInstant;
class VFSNode;
class VBinaryIOStream;

class VDirectoryIterationCallback {
    public:

        VDirectoryIterationCallback() {}
        virtual ~VDirectoryIterationCallback() {}

        virtual bool handleNextNode(const VFSNode& node) = 0;
};

typedef std::vector<VFSNode> VFSNodeVector;

class VFSNode {
    public:

        static VString normalizePath(const VString& path);
        static VString denormalizePath(const VString& path);

        typedef enum {
            USER_HOME_DIRECTORY,        
            LOG_FILES_DIRECTORY,        
            USER_PREFERENCES_DIRECTORY, 
            CACHED_DATA_DIRECTORY,      
            APPLICATION_DATA_DIRECTORY, 
            CURRENT_WORKING_DIRECTORY,  
            EXECUTABLE_DIRECTORY        
        } KnownDirectoryIdentifier;
        static VFSNode getKnownDirectoryNode(KnownDirectoryIdentifier id, const VString& companyName, const VString& appName);
        static VFSNode getCurrentWorkingDirectory();
        static VFSNode getExecutableDirectory();
        static VFSNode getExecutable();

        static void safelyOverwriteFile(const VFSNode& target, Vs64 dataLength, VBinaryIOStream& dataStream);

        VFSNode();
        VFSNode(const VFSNode& rhs);
        VFSNode(const VString& path);
        VFSNode(const VFSNode& directory, const VString& childName);
        virtual ~VFSNode() {}

        VFSNode& operator=(const VFSNode& other);

        void setPath(const VString& path);
        void getPath(VString& path) const;
        const VString& getPath() const;
        void getName(VString& name) const;
        VString getName() const;
        void setName(const VString& name);
        void getParentPath(VString& parentPath) const;
        void getParentNode(VFSNode& parent) const;
        void getChildPath(const VString& childName, VString& childPath) const;
        void getChildNode(const VString& childName, VFSNode& child) const;

        void mkdirs() const;
        void mkdir() const;
        bool rm() const;
        bool rmDirContents() const;
        bool exists() const;
        VInstant creationDate() const;
        VInstant modificationDate() const;
        VFSize size() const;
        bool isFile() const;
        bool isDirectory() const;

        void renameToPath(const VString& newPath) const;
        void renameToName(const VString& newName) const;
        void renameToName(const VString& newName, VFSNode& nodeToUpdate) const;
        void renameToNode(const VFSNode& newNode) const;

        void list(VStringVector& children) const;
        void list(VFSNodeVector& children) const;
        void iterate(VDirectoryIterationCallback& callback) const;
        bool find(const VString& name, VFSNode& node) const;

        void readAll(VString& s, bool includeLineEndings = true);
        void readAll(VStringVector& lines);
        static VString readTextFile(const VString& path, bool includeLineEndings = true);
        static void readTextFile(const VString& path, VStringVector& lines);

        // The < operator is needed for to support STL sort(); others provided for completeness.
        // The purpose here is to allow a sorting a directory listing by name,
        // after calling VFSNode::list(). This is reasonable for many cases, but
        // note that the comparision is ultimately performed by strcmp().
        friend inline bool operator< (const VFSNode& lhs, const VFSNode& rhs);
        friend inline bool operator<=(const VFSNode& lhs, const VFSNode& rhs);
        friend inline bool operator>=(const VFSNode& lhs, const VFSNode& rhs);
        friend inline bool operator> (const VFSNode& lhs, const VFSNode& rhs);

    private:

        // These are the key functions that typically peculiar to each platform,
        // and are implemented in the platform-specific vfsnode_platform.cpp
        // files.

        static VString _platform_normalizePath(const VString& path);
        static VString _platform_denormalizePath(const VString& path);
        static VFSNode _platform_getKnownDirectoryNode(KnownDirectoryIdentifier id, const VString& companyName, const VString& appName);
        static VFSNode _platform_getExecutable();

        bool _platform_getNodeInfo(VFSNodeInfo& info) const;
        void _platform_createDirectory() const;
        bool _platform_removeDirectory() const;
        bool _platform_removeFile() const;
        void _platform_renameNode(const VString& newPath) const;

        void _platform_directoryIterate(VDirectoryIterationCallback& callback) const;

        VString mPath;  

};

inline bool operator< (const VFSNode& lhs, const VFSNode& rhs) { return lhs.mPath < rhs.mPath; }
inline bool operator<=(const VFSNode& lhs, const VFSNode& rhs) { return !operator>(lhs, rhs); }
inline bool operator>=(const VFSNode& lhs, const VFSNode& rhs) { return !operator<(lhs, rhs); }
inline bool operator> (const VFSNode& lhs, const VFSNode& rhs) { return  operator<(rhs, lhs); }

#endif /* vfsnode_h */