dataitem.hpp

#ifndef DATAITEM_H
#define DATAITEM_H
 
#include <vector>
#include <variant>
 
#include <stdint.h>
 
#include "debugprint.hpp"
#include "gameid.hpp"
#include "starcoord.hpp"
#include "quantity.hpp"
#include "json.hpp"
 
/*
 */
class DataItem
{
public:
    using Type = uint32_t;
    static constexpr Type type_invalid = 0;
    static constexpr Type type_integer = 1;
    static constexpr Type type_double = 2;
    static constexpr Type type_string = 3;
    static constexpr Type type_bool = 4;
    static constexpr Type type_id = 5;
    static constexpr Type type_starcoord = 6;
    static constexpr Type type_quantity = 7;
    static constexpr Type type_vector_integer = 8;
    static constexpr Type type_vector_double = 9;
    static constexpr Type type_vector_string = 10;
    static constexpr Type type_vector_bool = 11;
    static constexpr Type type_vector_id = 12;
    static constexpr Type type_vector_starcoord = 13;
    static constexpr Type type_vector_quantity = 14;
    // For shorter code
    using vector_integer = std::vector<int64_t>;
    using vector_double = std::vector<double>;
    using vector_bool = std::vector<bool>;
    using vector_id = std::vector<ObjectId>;
    using vector_string = std::vector<std::string>;
    using vector_starcoord = std::vector<StarCoord>;
    using vector_quantity = std::vector<Quantity>;
    // Type: type. bool: client writable (can be written by commands or not)
    using DataItemMetadata = std::pair<Type, bool>;
    using DataItemVariant = std::variant<std::monostate,
                                         int64_t,
                                         double,
                                         std::string,
                                         bool,
                                         ObjectId,
                                         StarCoord,
                                         Quantity,
                                         vector_integer,
                                         vector_double,
                                         vector_string,
                                         vector_bool,
                                         vector_id,
                                         vector_starcoord,
                                         vector_quantity>;

    static void registerDataItem(const std::string &dataItem, Type dataType, bool clientWritable) {
        if ( _dataitems_library.find( dataItem ) != _dataitems_library.end() )
            DebugPrint() << "overwriting dataItem '" << dataItem << "' because it's already registered! (only LAST one will be registered...)";
        _dataitems_library[ dataItem ] = DataItemMetadata(dataType, clientWritable);
    }

    static DataItemMetadata getDataItemMetadata(const std::string &dataItem) {
        auto library_find = _dataitems_library.find(dataItem);
        if (library_find != _dataitems_library.end())
            return library_find->second;
        return DataItemMetadata(type_invalid,false);
    }
 
public:
    DataItem()
        : _name()
        , _item() {}

    DataItem( const DataItem& other )
        : _name( other._name )
        , _item( other._item ) {}

    DataItem( const std::string& name )
        : _name( name )
        , _item() {
        auto metadata = getDataItemMetadata(name);
        if (metadata.first != type_invalid) {
            switch ( metadata.first ) {
            case type_integer: _item.emplace<int64_t>(); break;
            case type_double: _item.emplace<double>(); break;
            case type_string: _item.emplace<std::string>(); break;
            case type_bool: _item.emplace<bool>(); break;
            case type_id: _item.emplace<ObjectId>(); break;
            case type_starcoord: _item.emplace<StarCoord>(); break;
            case type_quantity: _item.emplace<Quantity>(); break;
            case type_vector_integer: _item.emplace<vector_integer>(); break;
            case type_vector_double: _item.emplace<vector_double>(); break;
            case type_vector_string: _item.emplace<vector_string>(); break;
            case type_vector_bool: _item.emplace<vector_bool>(); break;
            case type_vector_id: _item.emplace<vector_id>(); break;
            case type_vector_starcoord: _item.emplace<vector_starcoord>(); break;
            case type_vector_quantity: _item.emplace<vector_quantity>(); break;
            default:
                DebugPrint() << "unable to create DataItem (" << name << "): type is invalid??";
            }
        }
        else
            DebugPrint() << "unregistered DataItem: '" << name << "', dataItem not created.";
    }

    bool isValid() const {
        return !std::holds_alternative<std::monostate>(_item);
    }

    const std::string& name() const {
        return _name;
    }
 
    Type type() const {
        return _item.index();
    }
 
public:
    DataItem& operator=(const DataItem& other) = default;

    template <typename T,
             typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, DataItem> &&
                                         !std::is_same_v<std::decay_t<T>, nlohmann::json>
                                         >>
    DataItem& operator=( T&& value ) {
        std::get<std::decay_t<T>>(_item) = std::forward<T>(value);
        return *this;
    }

    template <typename T>
    operator T&() {
        return std::get<std::decay_t<T>>(_item);
    }

    template <typename T>
    operator const T&() const {
        return std::get<std::decay_t<T>>(_item);
    }

    template <typename T>
    T& as() {
        return std::get<std::decay_t<T>>(_item);
    }

    template <typename T>
    const T& as() const {
        return std::get<std::decay_t<T>>(_item);
    }

    template <typename T,
             typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, DataItem> &&
                                         !std::is_same_v<std::decay_t<T>, nlohmann::json>
                                         >>
    bool operator==(const T& value) const {
        if (auto* ptr = std::get_if<std::decay_t<T>>(&_item))
            return *ptr == value;
        return false;
    }

    template <typename T,
             typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, DataItem> &&
                                         !std::is_same_v<std::decay_t<T>, nlohmann::json>
                                         >>
    bool operator!=(const T& value) const {
        if (auto* ptr = std::get_if<std::decay_t<T>>(&_item))
            return *ptr != value;
        return true;
    }
 
    bool operator!=(const DataItem& other) const {
        return _item != other._item;
    }
 
    bool operator==(const DataItem& other) const {
        return _item == other._item;
    }

    template <typename T>
    T *accessPtr() {
        T* ret = std::get_if<std::decay_t<T>>(&_item);
        if ( ret == nullptr )
            DebugPrint() << "DataItem->access: '" << _name << "' type mismatch!";
        return ret;
    }
 
    DataItem& operator+=( const DataItem& other ) {
        size_t i = _item.index();
        if ( i == other._item.index() ) {
            switch ( i ){
            case type_integer: std::get<type_integer>(_item) += std::get<type_integer>(other._item); break;
            case type_double: std::get<type_double>(_item) += std::get<type_double>(other._item); break;
            case type_quantity: std::get<type_quantity>(_item) += std::get<type_quantity>(other._item); break;
            default: DebugPrint() << "DataItem '" << _name << "' += '" << other._name << "' types are not compatible!";
            }
        }
        else
            DebugPrint() << "DataItem '" << _name << "' += '" << other._name << "' type mismatch!";
        return *this;
    }
 
    template <typename T,
             typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, DataItem> &&
                                         !std::is_same_v<std::decay_t<T>, nlohmann::json>
                                         >>
    DataItem& operator+=( const T& value ) {
        std::get<std::decay_t<T>>(_item) += value;
        return *this;
    }

    DataItem& operator=(const nlohmann::json& JSON) {
        // Yes this is verbose, but we want full control on type conversion
        switch ( _item.index() )
        {
        case type_integer:
            _item = JSON.get<int64_t>();
            break;
        case type_double:
            _item = JSON.get<double>();
            break;
        case type_string:
            _item = JSON.get<std::string>();
            break;
        case type_bool: // manage both 0/!=0 and real booleans
            _item = JSON.is_boolean() ? JSON.get<bool>() : JSON != 0;
            break;
        case type_id:
            _item = JSON.get<ObjectId>();
            break;
        case type_starcoord:
            _item = JSON.get<StarCoord>();
            break;
        case type_quantity:
            _item = JSON.get<Quantity>();
            break;
        case type_vector_integer:
            _item = JSON.get<vector_integer>();
            break;
        case type_vector_double:
            _item = JSON.get<vector_double>();
            break;
        case type_vector_string:
            _item = JSON.get<vector_string>();
            break;
        case type_vector_bool:
            _item = JSON.get<vector_bool>();
            break;
        case type_vector_id:
            _item = JSON.get<vector_id>();
            break;
        case type_vector_starcoord:
            _item = JSON.get<vector_starcoord>();
            break;
        case type_vector_quantity:
            _item = JSON.get<vector_quantity>();
            break;
        default:
            DebugPrint() << "error creating DataItem from JSON (" << _name << "). Type is invalid??";
        }
        return *this;
    }

    DataItemVariant& raw() {
        return _item;
    }    
 
private:    
    // These are ALL the valid dataitems, with type
    inline static std::unordered_map<std::string, DataItemMetadata> _dataitems_library;
 
    std::string _name;
    DataItemVariant _item;
};
 
#endif // DATAITEM_H