gameobject.h

#ifndef GameObject_H
#define GameObject_H
 
#include <stdint.h>
 
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
 
#include "../utils/debugprint.hpp"
#include "../utils/json.hpp"
#include "../utils/dataitem.hpp"

class GameObject
    : public std::enable_shared_from_this<GameObject>
{
public:
    using undumpFactory = std::function<std::shared_ptr<GameObject>(ObjectId, const std::string &)>;

    static bool initialize(const std::string &storage_path);

    static void registerSubtype(const std::string &category,
                                undumpFactory undumpCb );
 
 
public: // Disk serialization stuff

    template<typename T>
    static std::shared_ptr<T> createFromJsonFile(const std::string &category, ObjectId id) {
        return std::dynamic_pointer_cast<T>( _createFromJsonFile( category, id ) );
    }

    nlohmann::json toJson();

    bool writeToJsonFile();
 
protected:
    virtual void _finalizeDump() {};

    virtual void _finalizeUndump(std::shared_ptr<GameObject> /* ptr */) {};

    virtual void _finalizeUndump() {};
 
private: // serialize part, private data
    inline static std::string _storage_folder;

    static std::string _create_filename(const std::string &category, ObjectId id);
    static std::shared_ptr<GameObject> _createFromJson(std::shared_ptr<GameObject> parent,
                                                       const nlohmann::json &json_data);
    static std::shared_ptr<GameObject> _createFromJsonFile(const std::string &category, ObjectId id);
 
public: // dataitems
    inline static DataItem invalidDataItem = DataItem();

    DataItem& addDataItem(const std::string &dataItem) {
        DataItem new_item( dataItem );
        if ( new_item.isValid() ) {
            const auto& i = _dataitems_map.find( new_item.name() );
            if (  i == _dataitems_map.end() )
                return _dataitems_map[ new_item.name() ] = new_item;
            else
                DebugPrint() << "dataItem multiple initialization for: '" << dataItem << "' (" << _object_category << "/" << _object_type << ").";
            return i->second;
        }
        return invalidDataItem;
    }

    bool hasDataItem(const std::string &dataItem) const {
        return _dataitems_map.find(dataItem) != _dataitems_map.end();
    }

    DataItem& accessDataItem(const std::string &dataItem) {
        auto var = _dataitems_map.find(dataItem);
        if (var != _dataitems_map.end()) {
            return var->second;
        }
        return invalidDataItem;
    }

    const DataItem& accessDataItem(const std::string &dataItem) const {
        auto var = _dataitems_map.find(dataItem);
        if (var != _dataitems_map.end()) {
            return var->second;
        }
        return invalidDataItem;
    }

    void dataItemsFromTemplate(const nlohmann::json& template_data);
 
private:
    std::map<std::string,DataItem> _dataitems_map;
 
 
public: // access to object header (category, type, id, father)
    inline const std::string &category() const { return _object_category; }

    inline const std::string &type() const { return _object_type; }

    ObjectId id() const { return _object_id; }

    void reparent(std::shared_ptr<GameObject> new_parent);
 
private: // private header stuff
    std::string _object_category;
    std::string _object_type;
    ObjectId _object_id;
 
public: // multi-threading support (locks)
    void lock();
    void unlock();
 
private:
    std::mutex _object_access_mutex;
 
public: // Chldren access
    std::shared_ptr<GameObject> getParent() const {
        return _parent;
    }

    template <typename T>
    std::shared_ptr<T> getParent() const {
        return std::dynamic_pointer_cast<T>(_parent);
    }

    std::shared_ptr<GameObject> getSibling(ObjectId id) {
        return _parent != nullptr ? _parent->getChild(id) : nullptr;
    }

    template <typename T>
    std::shared_ptr<T> getSibling(ObjectId id) {
        return _parent != nullptr ? _parent->getChild<T>(id) : nullptr;
    }

    std::shared_ptr<GameObject> getChild(ObjectId id) {
        auto d = _children_id_map.find(id);
        return d != _children_id_map.end() ? d->second : nullptr;
    }

    template <typename T>
    std::shared_ptr<T> getChild(ObjectId id) {
        auto d = _children_id_map.find(id);
        return d != _children_id_map.end() ? std::dynamic_pointer_cast<T>(d->second)
                                           : nullptr;
    }

    bool hasChild(ObjectId id);

    inline std::map<ObjectId, std::shared_ptr<GameObject>> &childrenMap() {
        return _children_id_map;
    }
 
private: // parent and children management
    std::shared_ptr<GameObject> _parent;
 
    std::map<ObjectId, std::shared_ptr<GameObject>> _children_id_map;
    std::map<std::string, std::set<std::shared_ptr<GameObject>>> _children_category_map;
 
    static inline std::map<std::string, GameObject::undumpFactory> _register_functions;
 
protected: // Constructor, destructor and internal functions
    GameObject(const std::string &category,
               ObjectId id,
               const std::string &type);
    virtual ~GameObject();
 
public: // operations functions
    virtual void tick(double /*delta_time_s*/, double /*total_time_s*/) {};
};
 
 
#endif // GameObject_H