fs.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef COMMON_FS_H
#define COMMON_FS_H
 
#include "common/array.h"
#include "common/archive.h"
#include "common/hash-str.h"
#include "common/hashmap.h"
#include "common/ptr.h"
#include "common/str.h"
#include "common/ustr.h"
 
class AbstractFSNode;
 
namespace Common {
 
class FSNode;
class FSDirectory;
class SeekableReadStream;
class WriteStream;
class SeekableWriteStream;
 
class FSList : public Array<FSNode> {};
 
class FSNode : public ArchiveMember {
private:
    friend class ::AbstractFSNode;
    friend class FSDirectory;
    SharedPtr<AbstractFSNode>   _realNode;
    FSNode(AbstractFSNode *realNode);
 
public:
    enum ListMode {
        kListFilesOnly = 1,
        kListDirectoriesOnly = 2,
        kListAll = 3
    };
 
    FSNode();
 
    explicit FSNode(const Path &path);
    ~FSNode();
 
    bool operator<(const FSNode& node) const;
 
    bool exists() const;
 
    FSNode getChild(const String &name) const;
 
    bool getChildren(FSList &fslist, ListMode mode = kListDirectoriesOnly, bool hidden = true) const;
 
    U32String getDisplayName() const override;
 
    String getName() const override;
 
    String getFileName() const override;
 
    Path getPathInArchive() const override;
 
    virtual String getRealName() const;
 
    Path getPath() const;
 
    FSNode getParent() const;
 
    bool isDirectory() const override;
 
    void listChildren(Common::ArchiveMemberList &childList, const char *pattern = nullptr) const override;
 
    bool isReadable() const;
 
    bool isWritable() const;
 
    SeekableReadStream *createReadStream() const override;
 
    SeekableReadStream *createReadStreamForAltStream(AltStreamType altStreamType) const override;
 
    SeekableWriteStream *createWriteStream(bool atomic = true) const;
 
    bool createDirectory() const;
};
 
class FSDirectory : public Archive {
    FSNode _node;
    int _depth;
    bool _flat;
    bool _ignoreClashes;
    bool _includeDirectories;
 
    Path    _prefix; // string that is prepended to each cache item key
    void setPrefix(const Path &prefix);
 
    // Caches are case insensitive, clashes are dealt with when creating
    // Key is stored in lowercase.
    typedef HashMap<Path, FSNode, Path::IgnoreCaseAndMac_Hash, Path::IgnoreCaseAndMac_EqualTo> NodeCache;
    typedef HashMap<Path, Array<String>, Path::IgnoreCaseAndMac_Hash, Path::IgnoreCaseAndMac_EqualTo> NodeMapCache;
    mutable NodeCache   _fileCache, _subDirCache;
    mutable NodeMapCache    _fileMapCache, _dirMapCache;
    mutable bool _cached;
 
    // look for a match
    FSNode *lookupCache(NodeCache &cache, const Path &name) const;
 
    // cache management
    void cacheDirectoryRecursive(FSNode node, int depth, const Path& prefix) const;
 
    // fill cache if not already cached
    void ensureCached() const;
 
public:
    FSDirectory(const Path &name, int depth = 1, bool flat = false,
                bool ignoreClashes = false, bool includeDirectories = false);
    FSDirectory(const FSNode &node, int depth = 1, bool flat = false,
                bool ignoreClashes = false, bool includeDirectories = false);
 
    FSDirectory(const Path &prefix, const Path &name, int depth = 1,
                bool flat = false, bool ignoreClashes = false, bool includeDirectories = false);
    FSDirectory(const Path &prefix, const FSNode &node, int depth = 1,
                bool flat = false, bool ignoreClashes = false, bool includeDirectories = false);
 
    virtual ~FSDirectory();
 
    FSNode getFSNode() const;
 
    FSDirectory *getSubDirectory(const Path &name, int depth = 1, bool flat = false,
                                 bool ignoreClashes = false);
    FSDirectory *getSubDirectory(const Path &prefix, const Path &name, int depth = 1,
                                 bool flat = false, bool ignoreClashes = false);
 
    bool hasFile(const Path &path) const override;
 
    bool isPathDirectory(const Path &path) const override;
 
    int listMatchingMembers(ArchiveMemberList &list, const Path &pattern, bool matchPathComponents = false) const override;
 
    int listMembers(ArchiveMemberList &list) const override;
 
    const ArchiveMemberPtr getMember(const Path &path) const override;
 
    SeekableReadStream *createReadStreamForMember(const Path &path) const override;
 
    bool getChildren(const Common::Path &path, Common::Array<Common::String> &list, ListMode mode = kListDirectoriesOnly, bool hidden = true) const override;
 
    SeekableReadStream *createReadStreamForMemberAltStream(const Path &path, AltStreamType altStreamType) const override;
};
 
} // End of namespace Common
 
#endif //COMMON_FS_H