EntityGroup.hpp

#pragma once
#include <samchon/protocol/Entity.hpp>
#include <samchon/protocol/IEntityGroup.hpp>

namespace samchon
{
namespace protocol
{
    template <typename _Container, typename _ETy = Entity, typename T = _Container::value_type>
    class EntityGroup
        : public _Container,
        public virtual Entity, //CLASS
        public virtual IEntityGroup //INTERFACE
    {
    public:
        typedef _Container container_type;
        typedef T value_type;
        typedef _ETy entity_type;

    public:
        /* ------------------------------------------------------------------------------------
            CONSTRUCTORS
        ------------------------------------------------------------------------------------ */
        EntityGroup()
            : _Container(), Entity(),
            IEntityGroup()
        {
        };
        virtual ~EntityGroup() = default;

        virtual void construct(std::shared_ptr<library::XML> xml)
        {
            clear();
            if (xml->has(CHILD_TAG()) == false)
                return;

            std::shared_ptr<library::XMLList> &xmlList = xml->get(CHILD_TAG());

            if (std::is_same<_Container, std::vector<_Container::value_type, _Container::allocator_type>>::value == true)
            {
                //FOR RESERVE
                assign(xmlList->size(), nullptr);
                erase(begin(), end());
            }

            for (size_t i = 0; i < xmlList->size(); i++)
            {
                std::shared_ptr<library::XML> &xmlElement = xmlList->at(i);

                entity_type *entity = createChild(xmlElement);
                if (entity != nullptr)
                {
                    entity->construct(xmlList->at(i));
                    emplace_back(entity);
                }
            }
        };

    protected:
        virtual auto createChild(std::shared_ptr<library::XML>)->entity_type* = 0;

    public:
        /* ------------------------------------------------------------------------------------
            MODIFIERS
        ------------------------------------------------------------------------------------ */
        using _Container::erase;

        void erase(const std::string &key)
        {
            for (_Container::iterator it = begin(); it != end();)
                if ((*it)->key() == key)
                    it = erase(it);
                else
                    it++;
        };

        /* ------------------------------------------------------------------------------------
            GETTERS
        ------------------------------------------------------------------------------------ */
        auto has(const std::string &key) const -> bool
        {
            for (auto it = begin(); it != end(); it++)
                if ((*it)->key() == key)
                    return true;

            return false;
        };

        auto get(const std::string &key) -> value_type&
        {
            for (auto it = begin(); it != end(); it++)
                if ((*it)->key() == key)
                    return *it;

            throw std::exception("out of range");
        };

        auto get(const std::string &key) const -> const value_type&
        {
            for (auto it = begin(); it != end(); it++)
                if ((*it)->key() == key)
                    return *it;

            throw std::exception("out of range");
        };

        /* ------------------------------------------------------------------------------------
            EXPORTERS
        ------------------------------------------------------------------------------------ */
        virtual auto toXML() const -> std::shared_ptr<library::XML>
        {
            std::shared_ptr<library::XML> &xml = Entity::toXML();

            std::shared_ptr<library::XMLList> xmlList(new library::XMLList());
            xmlList->reserve(this->size());

            for (auto it = begin(); it != end(); it++)
                xmlList->push_back((*it)->toXML());

            xml->set(CHILD_TAG(), xmlList);
            return xml;
        };
    };
};
};