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;
    SeekableReadStream *createReadStreamForMemberAltStream(const Path &path, Common::AltStreamType altStreamType) const;

    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;
    char _separator = '\0';
};

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:

    virtual void clear();

private:
    friend class Singleton<SingletonBaseType>;
    SearchManager();
};

#define SearchMan       Common::SearchManager::instance()

} // namespace Common

#endif