archive.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_ARCHIVE_H
#define COMMON_ARCHIVE_H
 
#include "common/error.h"
#include "common/hashmap.h"
#include "common/hash-str.h"
#include "common/list.h"
#include "common/path.h"
#include "common/ptr.h"
#include "common/singleton.h"
#include "common/str.h"
 
namespace Common {
 
class ArchiveMember;
class FSNode;
class SeekableReadStream;
 
enum class AltStreamType {
    Invalid,
 
    MacFinderInfo,
    MacResourceFork,
};
 
typedef SharedPtr<ArchiveMember> ArchiveMemberPtr; 
typedef List<ArchiveMemberPtr> ArchiveMemberList;  
class ArchiveMember {
public:
    virtual ~ArchiveMember();
    virtual SeekableReadStream *createReadStream() const = 0; 
    virtual SeekableReadStream *createReadStreamForAltStream(AltStreamType altStreamType) const = 0; 
    virtual String getName() const = 0;
 
    virtual Path getPathInArchive() const = 0; 
    virtual String getFileName() const = 0; 
    virtual bool isDirectory() const; 
    virtual void listChildren(ArchiveMemberList &childList, const char *pattern = nullptr) const; 
    virtual U32String getDisplayName() const; 
    virtual bool isInMacArchive() const; 
};
 
struct ArchiveMemberDetails {
    ArchiveMemberPtr arcMember;
    Common::String arcName;
 
    ArchiveMemberDetails(const ArchiveMemberPtr &arcMember_, const Common::String &_arcName) : arcMember(arcMember_), arcName(_arcName) {
    }
};
typedef List<ArchiveMemberDetails> ArchiveMemberDetailsList; 
struct ArchiveMemberListComparator {
    bool operator()(const ArchiveMemberPtr &a, const ArchiveMemberPtr &b) {
        return a->getName() < b->getName();
    }
};
 
class Archive;
 
class GenericArchiveMember : public ArchiveMember {
public:
    GenericArchiveMember(const Common::String &pathStr, const Archive &parent); 
    GenericArchiveMember(const Common::Path &path, const Archive &parent); 
    String getName() const override;        
    Path getPathInArchive() const override;       
    String getFileName() const override; 
    SeekableReadStream *createReadStream() const override; 
    SeekableReadStream *createReadStreamForAltStream(AltStreamType altStreamType) const override; 
    bool isDirectory() const override;
    void listChildren(ArchiveMemberList &childList, const char *pattern) const override;
 
private:
    const Archive &_parent;
    const Common::Path _path;
};
 
 
class Archive {
public:
    Archive() : _mapsAreReady(false) { }
 
    virtual ~Archive() { }
 
    virtual bool hasFile(const Path &path) const = 0;
 
    virtual bool isPathDirectory(const Path &path) const;
 
    virtual int listMatchingMembers(ArchiveMemberList &list, const Path &pattern, bool matchPathComponents = false) const;
 
    virtual int listMembers(ArchiveMemberList &list) const = 0;
 
    virtual const ArchiveMemberPtr getMember(const Path &path) const = 0;
 
    virtual SeekableReadStream *createReadStreamForMember(const Path &path) const = 0;
 
    virtual SeekableReadStream *createReadStreamForMemberAltStream(const Path &path, AltStreamType altStreamType) const;
 
    virtual SeekableReadStream *createReadStreamForMemberNext(const Path &path, const Archive *starting) const {
        return createReadStreamForMember(path);
    }
 
    Common::Error dumpArchive(const Path &destPath);
 
    virtual char getPathSeparator() const;
 
    enum ListMode {
        kListFilesOnly = 1,
        kListDirectoriesOnly = 2,
        kListAll = 3
    };
 
    virtual bool getChildren(const Common::Path &path, Common::Array<Common::String> &list, ListMode mode = kListDirectoriesOnly, bool hidden = true) const;
 
private:
    void prepareMaps() const;
 
    mutable bool _mapsAreReady;
    typedef HashMap<String, bool, IgnoreCase_Hash, IgnoreCase_EqualTo> SubfileSet;
    typedef HashMap<Path, SubfileSet, Path::IgnoreCase_Hash, Path::IgnoreCase_EqualTo> AllfileMap;
    mutable AllfileMap _directoryMap, _fileMap;
};
 
class MemcachingCaseInsensitiveArchive;
 
// This is a shareable reference to a file contents stored in memory.
// It can be in 2 states: strong when it holds a strong reference in
// the sense of SharedPtr. Another state is weak when it only helds
// WeakPtr and thus may expire. Also strong reference is held by
// Returned memory stream. Hence once no memory streams and no
// strong referenceas are remaining, the block is freed.
class SharedArchiveContents {
public:
    SharedArchiveContents(byte *contents, uint32 contentSize) :
        _strongRef(contents, ArrayDeleter<byte>()), _weakRef(_strongRef),
        _contentSize(contentSize), _missingFile(false), _bypass(nullptr) {}
    SharedArchiveContents() : _strongRef(nullptr), _weakRef(nullptr), _contentSize(0), _missingFile(true), _bypass(nullptr) {}
    static SharedArchiveContents bypass(SeekableReadStream *stream) {
        return SharedArchiveContents(stream);
    }
 
private:
    SharedArchiveContents(SeekableReadStream *stream) : _strongRef(nullptr), _weakRef(nullptr), _contentSize(0), _missingFile(false), _bypass(stream) {}
 
    bool isFileMissing() const { return _missingFile; }
    SharedPtr<byte> getContents() const { return _strongRef; }
    uint32 getSize() const { return _contentSize; }
 
    bool makeStrong() {
        if (_strongRef || _contentSize == 0 || _missingFile)
            return true;
        _strongRef = SharedPtr<byte>(_weakRef);
        if (_strongRef)
            return true;
        return false;
    }
 
    void makeWeak() {
        // No need to make weak if we have no contents
        if (_contentSize == 0)
            return;
        _strongRef = nullptr;
    }
 
    SharedPtr<byte> _strongRef;
    WeakPtr<byte> _weakRef;
    uint32 _contentSize;
    bool _missingFile;
    SeekableReadStream *_bypass;
 
    friend class MemcachingCaseInsensitiveArchive;
};
 
class MemcachingCaseInsensitiveArchive : public Archive {
public:
    MemcachingCaseInsensitiveArchive(uint32 maxStronglyCachedSize = 512) : _maxStronglyCachedSize(maxStronglyCachedSize) {}
    SeekableReadStream *createReadStreamForMember(const Path &path) const override;
    SeekableReadStream *createReadStreamForMemberAltStream(const Path &path, Common::AltStreamType altStreamType) const override;
 
    virtual Path translatePath(const Path &path) const {
        return path.normalize();
    }
 
    virtual SharedArchiveContents readContentsForPath(const Path &translatedPath) const = 0;
    virtual SharedArchiveContents readContentsForPathAltStream(const Path &translatedPath, AltStreamType altStreamType) const;
 
private:
    struct CacheKey {
        CacheKey();
 
        Path path;
        AltStreamType altStreamType;
    };
 
    struct CacheKey_EqualTo {
        bool operator()(const CacheKey &x, const CacheKey &y) const;
    };
 
    struct CacheKey_Hash {
        uint operator()(const CacheKey &x) const;
    };
 
    SeekableReadStream *createReadStreamForMemberImpl(const Path &path, bool isAltStream, Common::AltStreamType altStreamType) const;
 
    mutable HashMap<CacheKey, SharedArchiveContents, CacheKey_Hash, CacheKey_EqualTo> _cache;
    uint32 _maxStronglyCachedSize;
};
 
class SearchSet : public Archive {
    struct Node {
        int     _priority;
        String  _name;
        Archive *_arc;
        bool    _autoFree;
        Node(int priority, const String &name, Archive *arc, bool autoFree)
            : _priority(priority), _name(name), _arc(arc), _autoFree(autoFree) {
        }
    };
    typedef List<Node> ArchiveNodeList;
    ArchiveNodeList _list;
 
    ArchiveNodeList::iterator find(const String &name);
    ArchiveNodeList::const_iterator find(const String &name) const;
 
    void insert(const Node& node); 
 
    bool _ignoreClashes;
 
public:
    SearchSet() : _ignoreClashes(false) { }
    virtual ~SearchSet() { clear(); }
 
    char getPathSeparator() const override { return '/'; }
 
    void add(const String& name, Archive *arch, int priority = 0, bool autoFree = true);
 
    void addDirectory(const String &name, const Path &directory, int priority = 0, int depth = 1, bool flat = false);
 
    void addDirectory(const String &name, const FSNode &directory, int priority = 0, int depth = 1, bool flat = false);
 
    void addDirectory(const Path &directory, int priority = 0, int depth = 1, bool flat = false);
    void addDirectory(const FSNode &directory, int priority = 0, int depth = 1, bool flat = false);
 
    void addSubDirectoryMatching(const FSNode &directory, const String &caselessName, int priority = 0, int depth = 1, bool flat = false) {
        addSubDirectoriesMatching(directory, caselessName, true, priority, depth, flat);
    }
 
    void addSubDirectoriesMatching(const FSNode &directory, String origPattern, bool ignoreCase, int priority = 0, int depth = 1, bool flat = false);
 
    void remove(const String& name);
 
    bool hasArchive(const String &name) const;
 
    Archive *getArchive(const String &name) const;
 
    virtual void clear();
 
    void setPriority(const String& name, int priority);
 
    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 listMatchingMembers(ArchiveMemberDetailsList &list, const Path &pattern, bool matchPathComponents = false) const;
    int listMembers(ArchiveMemberList &list) const override;
 
    const ArchiveMemberPtr getMember(const Path &path) const override;
 
    const ArchiveMemberPtr getMember(const Path &path, Archive **container) const;
 
    SeekableReadStream *createReadStreamForMember(const Path &path) const override;
 
    SeekableReadStream *createReadStreamForMemberAltStream(const Path &path, AltStreamType altStreamType) const override;
 
    SeekableReadStream *createReadStreamForMemberNext(const Path &path, const Archive *starting) const override;
 
    void setIgnoreClashes(bool ignoreClashes) { _ignoreClashes = ignoreClashes; }
 
    bool getChildren(const Common::Path &path, Common::Array<Common::String> &list, ListMode mode = kListDirectoriesOnly, bool hidden = true) const override;
};
 
 
class SearchManager : public Singleton<SearchManager>, public SearchSet {
public:
 
    void clear() override;
 
private:
    friend class Singleton<SingletonBaseType>;
    SearchManager();
};
 
#define SearchMan       Common::SearchManager::instance()
 
} // namespace Common
 
#endif