Inventory.h

 
#ifndef ACTIVE_SERIALISE_INVENTORY
#define ACTIVE_SERIALISE_INVENTORY
 
#include "Active/Serialise/Inventory/Entry.h"
 
#include <unordered_map>
#include <vector>
 
namespace active::serialise {
    
    class Inventory : public std::vector<Entry> {
    public:
        
        // MARK: - Types
        
        using value = Entry;
        using base = std::vector<value>;
        using size_type = base::size_type;
        using iterator = typename base::iterator;
        using Option = std::optional<Inventory>;
        using Item = value;
        using ItemOption = std::optional<Inventory::Item>;
        using Sequence = std::vector<std::pair<int16_t, const_iterator>>;
 
        // MARK: - Constructors
        
        Inventory() : base() {}
        Inventory(base entries) : base(entries) { m_isFilled = true; }
        
        // MARK: - Variables
        
        bool isEveryItemAccepted = false;
        
        // MARK: - Functions (const)
        
        bool isFilled() const { return m_isFilled; }
        size_type attributeSize(bool isRequiredOnly = false) const;
        Sequence sequence() const;
 
        // MARK: - Functions (mutating)
        
        Inventory& withType(const std::type_info* ownerType);
        Inventory& merge(const Inventory& inventory);
        iterator registerIncoming(const Identity& identity);
        void resetAvailable();
        iterator findEntry(const Identity& identity, const std::type_info* owner = nullptr);
        iterator findEntry(int16_t ind, const std::type_info* owner = nullptr);
        bool setRequired(bool mustHave, int16_t ind, const std::type_info* owner = nullptr);
        
    private:
        bool m_isFilled = false;
    };
    
}
 
#endif  //ACTIVE_SERIALISE_INVENTORY