EntityGroup.hpp

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

#include <algorithm>

namespace samchon
{
namespace protocol
{
    template <typename Container, typename T, typename Key = std::string>
    class EntityGroup
        : public Container, // CONTAINS CHILD ENTITY ELEMENTS
        public virtual Entity<Key>, // I AM A TYPE OF ENTITY TOO
        public EntityGroupBase  //INTERFACE
    {
    public:
        typedef Container container_type;
        typedef T child_type;

    public:
        /* ------------------------------------------------------------------------------------
            CONSTRUCTORS
        ------------------------------------------------------------------------------------ */
        using container_type::container_type;

        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> &xml_list = xml->get(CHILD_TAG());

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

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

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

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

    public:
        /* ------------------------------------------------------------------------------------
            ACCESSORS
        ------------------------------------------------------------------------------------ */
        using container_type::erase;

        void erase(const typename child_type::key_type &key)
        {
            for (auto it = begin(); it != end(); )
                if ((*it)->key() == key)
                    it = erase(it);
                else
                    it++;
        };
        
        auto find(const typename child_type::key_type &key) -> typename container_type::iterator
        {
            return std::find_if
            (
                begin(), end(),
                [key](const container_type::value_type &entity) -> bool
                {
                    return entity->key() == key;
                }
            );
        };

        auto find(const typename child_type::key_type &key) const -> typename container_type::const_iterator
        {
            return std::find_if
            (
                begin(), end(),
                [key](const container_type::value_type &entity) -> bool
                {
                    return entity->key() == key;
                }
            );
        };

        auto has(const typename child_type::key_type &key) const -> bool
        {
            return std::any_of
            (
                begin(), end(),
                [key](const container_type::value_type &entity) -> bool
                {
                    return entity->key() == key;
                }
            );
        };

        auto count(const typename child_type::key_type &key) const -> size_t
        {
            return std::count_if
            (
                begin(), end(),
                [key](const container_type::value_type &entity) -> bool
                {
                    return entity->key() == key;
                }
            );
        };

        auto get(const typename child_type::key_type &key) -> typename container_type::value_type&
        {
            auto it = std::find_if
                (
                    begin(), end(),
                    [key](const container_type::value_type &entity) -> bool
                    {
                        return entity->key() == key;
                    }
                );

            if (it == end())
                throw std::out_of_range("out of range");

            return *it;
        };

        auto get(const typename child_type::key_type &key) const -> const typename container_type::value_type&
        {
            auto it = std::find_if
                (
                    begin(), end(),
                    [key](const container_type::value_type &entity) -> bool
                    {
                        return entity->key() == key;
                    }
                );

            if (it == end())
                throw std::out_of_range("out of range");

            return *it;
        };

        /* ------------------------------------------------------------------------------------
            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;
        };
    };
};
};