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