HECLDatabase.hpp

#ifndef HECLDATABASE_HPP
#define HECLDATABASE_HPP

#include <iterator>
#include <string>
#include <functional>
#include <vector>
#include <map>
#include <unordered_map>
#include <memory>
#include <atomic>
#include <stdexcept>
#include <stdint.h>

#include <Athena/IStreamReader.hpp>

#include "HECL.hpp"

namespace HECL
{
namespace Database
{

class PackageDepsgraph
{
public:
    struct Node
    {
        enum
        {
            NODE_DATA,
            NODE_GROUP
        } type;
        SystemString path;
        class ObjectBase* projectObj;
        Node* sub;
        Node* next;
    };
private:
    friend class Project;
    std::vector<Node> m_nodes;
public:
    const Node* getRootNode() const {return &m_nodes[0];}
};

class IDataSpec
{
public:
    struct ExtractPassInfo
    {
        SystemString srcpath;
        ProjectPath subpath;
    };
    virtual bool canExtract(const ExtractPassInfo& info) {(void)info;return false;}
    virtual void doExtract(const ExtractPassInfo& info) {(void)info;}

    struct PackagePassInfo
    {
        PackageDepsgraph& depsgraph;
        ProjectPath subpath;
    };
    virtual bool canPackage(const PackagePassInfo& info) {(void)info;return false;}
    virtual void doPackage(const PackagePassInfo& info) {(void)info;}
};

struct DataSpecEntry
{
    SystemString name;
    SystemString desc;
    std::function<IDataSpec*(void)> factory;
};
extern const HECL::Database::DataSpecEntry DATA_SPEC_REGISTRY[];

class ObjectBase
{
    friend class Project;
    SystemString m_path;
protected:

    enum DataEndianness
    {
        DE_NONE,
        DE_BIG, 
        DE_LITTLE 
    };

    enum DataPlatform
    {
        DP_NONE,
        DP_GENERIC, 
        DP_REVOLUTION, 
        DP_CAFE 
    };

    typedef std::function<void(const void* data, size_t len)> FDataAppender;

    virtual bool _cookObject(FDataAppender dataAppender,
                             DataEndianness endianness, DataPlatform platform)
    {(void)dataAppender;(void)endianness;(void)platform;return true;}

    typedef std::function<void(ObjectBase*)> FDepAdder;

    virtual void _gatherDeps(FDepAdder depAdder)
    {(void)depAdder;}

public:
    ObjectBase(const SystemString& path)
    : m_path(path) {}

    inline const SystemString& getPath() const {return m_path;}

};


class Project
{
public:
    typedef std::vector<std::pair<const DataSpecEntry&, bool>> CompiledSpecs;
private:
    ProjectRootPath m_rootPath;
    CompiledSpecs m_compiledSpecs;
public:
    Project(const HECL::ProjectRootPath& rootPath);

    class ConfigFile
    {
        SystemString m_filepath;
        std::vector<std::string> m_lines;
        FILE* m_lockedFile = NULL;
    public:
        ConfigFile(const Project& project, const SystemString& name);
        const std::vector<std::string>& lockAndRead();
        void addLine(const std::string& line);
        void removeLine(const std::string& refLine);
        bool checkForLine(const std::string& refLine);
        void unlockAndDiscard();
        void unlockAndCommit();
    };
    ConfigFile m_specs;
    ConfigFile m_paths;
    ConfigFile m_groups;

    class IndexFile
    {
        SystemString m_filepath;
        const Project& m_project;
        size_t m_maxPathLen = 0;
        size_t m_onlyUpdatedMaxPathLen = 0;
        FILE* m_lockedFile = NULL;
    public:
        class Entry
        {
            friend class IndexFile;
            ProjectPath m_path;
            HECL::Time m_lastModtime;
            bool m_updated = false;
            Entry(const ProjectPath& path, const HECL::Time& lastModtime)
            : m_path(path), m_lastModtime(lastModtime) {}
            Entry(const ProjectPath& path);
        };
    private:
        size_t m_updatedCount = 0;
        std::vector<Entry> m_entryStore;
        std::unordered_map<ProjectPath, Entry*> m_entryLookup;
    public:
        IndexFile(const Project& project);
        const std::vector<Entry>& lockAndRead();
        const std::vector<ProjectPath*> getChangedPaths();
        void addOrUpdatePath(const ProjectPath& path);
        void unlockAndDiscard();
        void unlockAndCommit(bool onlyUpdated=false);
    };
    IndexFile m_index;

    class PackageException : public std::runtime_error {};

    enum Cost
    {
        C_NONE,
        C_LIGHT,
        C_MEDIUM,
        C_HEAVY
    };

    void registerLogger(HECL::FLogger logger);

    inline const ProjectRootPath& getProjectRootPath() const {return m_rootPath;}

    bool addPaths(const std::vector<ProjectPath>& paths);

    bool removePaths(const std::vector<ProjectPath>& paths, bool recursive=false);

    bool addGroup(const ProjectPath& path);

    bool removeGroup(const ProjectPath& path);

    inline const CompiledSpecs& getDataSpecs() {return m_compiledSpecs;}

    bool enableDataSpecs(const std::vector<SystemString>& specs);

    bool disableDataSpecs(const std::vector<SystemString>& specs);

    bool cookPath(const ProjectPath& path,
                  std::function<void(SystemString&, Cost, unsigned)> feedbackCb,
                  bool recursive=false);

    void interruptCook();

    bool cleanPath(const ProjectPath& path, bool recursive=false);

    PackageDepsgraph buildPackageDepsgraph(const ProjectPath& path);

};

}
}

#endif // HECLDATABASE_HPP