XMLPolygon.h

 
#ifndef ACTIVE_SERIALISE_XML_XML_POLYGON
#define ACTIVE_SERIALISE_XML_XML_POLYGON
 
#include "Active/Geometry/Polygon.h"
#include "Active/Serialise/Package/Package.h"
#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
#include "Active/Serialise/XML/Package/Wrapper/Geometry/XMLPolyPoint.h"
#include "Active/Utility/String.h"
 
#include <concepts>
 
namespace active::serialise::xml {
 
    template<class Vert>
    concept IsPolyPoint = std::is_base_of<geometry::PolyPoint, Vert>::value;
    template<class VertWrap>
    concept IsPointWrap = std::is_base_of<XMLPolyPoint, VertWrap>::value;
 
    template<class Vert = geometry::PolyPoint, class VertWrap = XMLPolyPoint> requires IsPolyPoint<Vert> && IsPointWrap<VertWrap>
    class XMLSolidPolygon : public Package, public std::reference_wrapper<geometry::Polygon> {
    public:
        
        // MARK: - Types
        
            //Base class type
        using base = std::reference_wrapper<geometry::Polygon>;
        
        enum FieldIndex {
            vertex,
            topID,
        };
        
        // MARK: - Static variables
        
        static inline utility::String tag = "polygon";
        
        static inline std::array fieldID = {
            Identity{"vertex"},
            Identity{"topID"},
        };
            
        // MARK: - Constructor
 
            //NB: Value is only mutated within import processes, in which case the object must be mutable (i.e. const discard is safe)
        XMLSolidPolygon(const geometry::Polygon& polygon) : base(const_cast<geometry::Polygon&>(polygon)) { m_topID = polygon.getTopID(); }
            //NB: Value is only mutated within import processes, in which case the object must be mutable (i.e. const discard is safe)
        XMLSolidPolygon(const geometry::Polygon& polygon, const utility::String& customTag) : base(const_cast<geometry::Polygon&>(polygon)), m_tag(customTag) {
            m_topID = polygon.getTopID();
        }
        
        // MARK: - Functions (const)
        
        virtual bool fillInventory(Inventory& inventory) const override {
            using enum Entry::Type;
            inventory.merge(Inventory{
                {
                    { fieldID[topID], topID, attribute, (m_topID != 0) },
                    { fieldID[vertex], vertex, static_cast<uint32_t>(get().size()), std::nullopt, (get().size() > 0) },
                }
            }.withType(&typeid(XMLSolidPolygon<Vert, VertWrap>)));
            return true;
        }
        virtual Cargo::Unique getCargo(const Inventory::Item& item) const override {
            if (item.ownerType != &typeid(XMLSolidPolygon<Vert>))
                return nullptr;
            switch (item.index) {
                case FieldIndex::vertex:
                    return std::make_unique<VertWrap>((item.available < static_cast<uint32_t>(get().vertSize())) ?
                                                      *(get()[static_cast<geometry::vertex_index>(item.available)]) : m_vertex);
                case FieldIndex::topID:
                    return std::make_unique<ValueWrap<geometry::vertex_id>>(m_topID);
                default:
                    return nullptr; //Requested an unknown index
            }
        }
        
        // MARK: - Functions (mutating)
        
        virtual void setDefault() override {
            base::get().clear();    //The default state is an empty polygon
        }
        virtual bool validate() override {
            base::get().setTopID(m_topID);
            return true;
        }
        virtual bool insert(Cargo::Unique&& cargo, const Inventory::Item& item) override {
            if (item.ownerType != &typeid(XMLSolidPolygon<Vert, VertWrap>))
                return true;
            switch (item.index) {
                case FieldIndex::vertex:
                    base::get().emplace_back(m_vertex);
                    break;
                default:
                    break;
            }
            return true;
        }
        
    private:
        utility::String::Option m_tag;
        mutable Vert m_vertex;
        mutable geometry::vertex_id m_topID = 0;
    };
    
    
    template<class Hole>
    concept IsPolygon = std::is_base_of<geometry::Polygon, Hole>::value;
    template<class HoleWrap>
    concept IsHoleWrap = std::is_base_of<XMLSolidPolygon<>, HoleWrap>::value;
 
    
    template<class Vert = geometry::PolyPoint, class VertWrap = XMLPolyPoint,
            class Hole = geometry::Polygon, class HoleWrap = XMLSolidPolygon<Vert, VertWrap>>
            requires IsPolyPoint<Vert> && IsPointWrap<VertWrap> && IsPolygon<Hole> && IsHoleWrap<HoleWrap>
    class XMLPolygon : public XMLSolidPolygon<Vert, VertWrap> {
    public:
        
        // MARK: - Types
        
            //Base class type
        using base = XMLSolidPolygon<Vert, VertWrap>;
        
        enum FieldIndex {
            hole,
        };
        
        // MARK: - Static variables
        
        static inline utility::String tag = "polygon";
        
        static inline std::array fieldID = {
            Identity{"hole"},
        };
            
        // MARK: - Constructor
 
        XMLPolygon(const geometry::Polygon& polygon) : base{polygon}    {}
        XMLPolygon(const geometry::Polygon& polygon, const utility::String& customTag) : base{polygon, customTag}   {}
        
        // MARK: - Functions (const)
        
        virtual bool fillInventory(Inventory& inventory) const override {
            base::fillInventory(inventory);
            inventory.merge(Inventory{
                {
                    { fieldID[hole], hole, static_cast<uint32_t>(base::get().getHoleSize()), std::nullopt, (base::get().getHoleSize() > 0) },
                }
            }.withType(&typeid(XMLPolygon<Vert, VertWrap, Hole, HoleWrap>)));
            return true;
        }
        virtual Cargo::Unique getCargo(const Inventory::Item& item) const override {
            if (item.ownerType != &typeid(XMLPolygon<Vert>))
                return base::getCargo(item);
            switch (item.index) {
                case FieldIndex::hole:
                    return std::make_unique<HoleWrap>((item.available < static_cast<uint32_t>(base::get().getHoleSize())) ?
                                                      *(base::get().getHole(static_cast<geometry::part_index>(item.available))) : m_hole);
                default:
                    return nullptr; //Requested an unknown index
            }
        }
        
        // MARK: - Functions (mutating)
 
        virtual bool insert(Cargo::Unique&& cargo, const Inventory::Item& item) override {
            if (item.ownerType != &typeid(XMLPolygon<Vert, VertWrap, Hole, HoleWrap>))
                return base::insert(std::move(cargo), item);
            switch (item.index) {
                case FieldIndex::hole:
                    base::get().emplaceHole(clone(m_hole));
                    break;
                default:
                    break;
            }
            return true;
        }
        
    private:
        mutable Hole m_hole;
    };
 
}
 
#endif  //ACTIVE_SERIALISE_XML_XML_POLYGON