Object.h

 
#ifndef ACTIVE_SERIALISE_DOC_OBJECT
#define ACTIVE_SERIALISE_DOC_OBJECT
 
#include "Active/Serialise/Document/Handler.h"
#include "Active/Serialise/Package/Package.h"
#include "Active/Setting/ValueSetting.h"
 
namespace active::serialise::doc {
    
    class Object;
    
    class Object : public serialise::Package {
    public:
 
        // MARK: - Constants
 
        static inline utility::String defaultTag = "obj";
 
        // MARK: - Types
        
        using Unique = std::unique_ptr<Object>;
        using Shared = std::shared_ptr<Object>;
        using Option = std::optional<Object>;
        using base = std::vector<Object>;
        using Values = std::vector<setting::ValueSetting>;
        
        // MARK: - Constructors
        
        Object() {}
        Object(const utility::String& type,
               utility::String::Option objTag = std::nullopt);
        Object(const Object& source) = default;
        Object(Object&& source) noexcept = default;
        
        // MARK: - Public variables
        
        utility::String docType;
        utility::String tag;
        std::vector<Object> objects;
        Values values;
        
        // MARK: Operators
        
        Object& operator=(Object&& source) = default;
        Object& operator<<(Object& object) {
            objects.emplace_back(std::move(object));
            return *this;
        }
        Object& operator<<(Object&& object) {
            objects.emplace_back(std::move(object));
            return *this;
        }
        Object& operator<<(setting::ValueSetting&& value) {
            values.emplace_back(std::move(value));
            return *this;
        }
        
        // MARK: - Functions (const)
        
        const Object* object(const utility::String& tag) const;
        template<typename T>
        std::unique_ptr<T> object(const utility::String& tag = utility::String{}) const {
            if (!m_handler)
                return nullptr;
            if (!tag.empty()) {
                if (const auto* source = object(tag); source != nullptr) {
                    return source->object<T>();
                }
                return nullptr;
            }
            return std::unique_ptr<T>{m_handler->reconstruct<T>(*this)};
        }
        const setting::ValueSetting::Option value(const utility::String& name) const;
        virtual bool fillInventory(serialise::Inventory& inventory) const override;
        virtual serialise::Cargo::Unique getCargo(const serialise::Inventory::Item& item) const override;
        const Object& usingHandler(std::shared_ptr<Handler> handler) const;
        
        // MARK: - Functions (mutating)
        
        virtual void setDefault() override;
        virtual bool validate() override;
        virtual bool insert(Cargo::Unique&& cargo, const serialise::Inventory::Item& item) override;
        Object& withType(const utility::String& newType) {
            docType = newType;
            return *this;
        }
        Object& withTag(const utility::String& newTag) {
            tag = newTag;
            return *this;
        }
        
    private:
        mutable std::shared_ptr<Handler> m_handler;
        mutable setting::ValueSetting m_incoming;
    };
 
}
 
#endif  //ACTIVE_SERIALISE_DOC_OBJECT