StaticEntityGroup.hpp

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

#include <algorithm>

namespace samchon
{
namespace protocol
{
    template <typename Container, typename Key = std::string>
    class StaticEntityGroup
        : 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;

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

        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());
            size_t i = 0;

            assign(xml_list->size(), container_type::value_type());
            for (auto it = begin(); it != end(); it++)
                it->construct(xml_list->at(i++));
        };

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

        void erase(const typename container_type::value_type::key_type &key)
        {
            for (auto it = begin(); it != end(); )
                if (it->key() == key)
                    it = erase(it);
                else
                    it++;
        };
        
        auto find(const typename container_type::value_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 container_type::value_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 container_type::value_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 container_type::value_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 container_type::value_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 container_type::value_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;
        };
    };
};
};