HECLRuntime.hpp

#ifndef HECLRUNTIME_HPP
#define HECLRUNTIME_HPP

#include <memory>
#include <vector>
#include <atomic>

#include "HECL.hpp"

namespace HECL
{
namespace Runtime
{

class Entity
{
public:
    enum Type
    {
        ENTITY_NONE,
        ENTITY_OBJECT,
        ENTITY_GROUP
    };

private:
    Type m_type;
    const std::string& m_path;
    bool m_loaded = false;

    friend class Group;
    friend class ObjectBase;
    Entity(Type type, const std::string& path)
    : m_type(type), m_path(path) {}

public:
    inline Type getType() const {return m_type;}

    inline const std::string& getPath() const {return m_path;}

    inline bool isLoaded() const {return m_loaded;}
};

class Group : public Entity
{
public:
    typedef std::vector<std::weak_ptr<const class RuntimeObjectBase>> GroupObjectsVector;
private:
    friend class HECLRuntime;
    GroupObjectsVector m_objects;
    Group(const std::string& path)
    : Entity(ENTITY_GROUP, path) {}
public:
    inline const GroupObjectsVector& getObjects() const {return m_objects;}
};

class ObjectBase : public Entity
{
    std::shared_ptr<const Group> m_parent;
protected:

    virtual bool _objectFinishedLoading(const void* data, size_t len)
    {(void)data;(void)len;return true;}

    virtual void _objectWillUnload() {}

public:
    ObjectBase(const Group* group, const std::string& path)
    : Entity(ENTITY_OBJECT, path), m_parent(group) {}

    inline const Group* getParentGroup() {return m_parent.get();}
};

class Runtime
{
public:
    Runtime(const SystemString& hlpkDirectory);
    ~Runtime();

    struct SGroupLoadStatus
    {
        std::atomic_bool done;
        std::atomic_size_t completedObjects;
        std::atomic_size_t totalObjects;
    };

    std::shared_ptr<Entity> loadSync(const Hash& pathHash);

    std::shared_ptr<Entity> loadAsync(const Hash& pathHash,
                                      SGroupLoadStatus* statusOut=NULL);

};

}
}

#endif // HECLRUNTIME_HPP