Entry.h

 
#ifndef ACTIVE_SERIALISE_ENTRY
#define ACTIVE_SERIALISE_ENTRY
 
#include "Active/Serialise/Inventory/Identity.h"
 
#include <cstdint>
#include <optional>
#include <typeindex>
 
namespace active::serialise {
    
    struct Entry {
        
        enum class Type {
            attribute,
            element,
        };
        
        using enum Type;
        
        class ID {
        public:
            ID(Identity&& identity) : m_identity{std::move(identity)} {}
            ID(const Identity& identity) : m_wrapped{std::reference_wrapper<const Identity>{identity}} {}
 
            const Identity& identity() const { return m_wrapped ? m_wrapped->get() : m_identity; }
 
        private:
            Identity m_identity;
            std::optional<std::reference_wrapper<const Identity>> m_wrapped;
        };
        
        // MARK: - Constructors
        
        Entry(const Identity& ident, int16_t ind, Type type, bool mustHave = true, const std::type_info* owner = nullptr) :
                Entry{ID{ident}, ind, type, mustHave, owner} {}
        Entry(Identity&& ident, int16_t ind, Type type, bool mustHave = true, const std::type_info* owner = nullptr) :
                Entry{ID{std::move(ident)}, ind, type, mustHave, owner} {}
        Entry(const Identity& ident, int16_t ind, size_t howMany, std::optional<size_t> max = 1, bool mustHave = true, const std::type_info* owner = nullptr) :
                Entry{ID{ident}, ind, howMany, max, mustHave, owner} {}
        Entry(Identity&& ident, int16_t ind, size_t howMany, std::optional<size_t> max = 1, bool mustHave = true, const std::type_info* owner = nullptr) :  Entry{ID{std::move(ident)}, ind, howMany, max, mustHave, owner} {}
        Entry(const Entry& source) = default;
        Entry& operator=(const Entry& source) = default;
 
        // MARK: - Variables
        
        const std::type_info* ownerType = nullptr;
        size_t available = 0;
        int16_t index = 0;
        bool required = true;
        
        // MARK: - Functions (const)
        
        const Identity& identity() const { return m_id.identity(); }
        /*
            Determine if the entry is an attribute
            @return True if the entry is repeating
        */
        bool isAttribute() const { return (m_type == attribute); }
        bool isRepeating() const { return (!m_maximum || (m_maximum > 1)); }
        std::optional<size_t> maximum() const { return isAttribute() ? 1 : m_maximum; }
 
        // MARK: - Functions (mutating)
        
        void setIdentity(const Identity& ident) { m_id = ID{ident}; }
        void setIdentity(Identity&& ident) { m_id = ID{std::move(ident)}; }
        Entry& withOwner(const std::type_info* owner) {
            ownerType = owner;
            return *this;
        }
        bool bumpAvailable() {
            if (!maximum() || (available < maximum())) {
                ++available;
                return true;
            }
            return false;
        }
        
    private:
        Entry(ID&& id, int16_t ind, Type type, bool mustHave, const std::type_info* owner) : m_id{id} {
            index = ind;
            m_type = type;
            required = mustHave;
            if (required)
                available = 1;
            ownerType = owner;
        }
        Entry(ID&& id, int16_t ind, size_t howMany, std::optional<size_t> max, bool mustHave, const std::type_info* owner) : m_id{id} {
            index = ind;
            m_maximum = max;
            if (m_maximum.has_value() && (*m_maximum <= 0))
                m_maximum = 1;
            available = howMany;
            required = mustHave;
            ownerType = owner;
            m_type = element;
        }
        
        ID m_id;
        std::optional<size_t> m_maximum = 1;
        Type m_type = element;
    };
    
}
 
#endif  //ACTIVE_SERIALISE_ENTRY