ExternalSystemArray.hpp

#pragma once
#include <samchon/API.hpp>

#include <samchon/protocol/SharedEntityDeque.hpp>
#   include <samchon/templates/external/ExternalSystem.hpp>
#include <samchon/templates/external/base/ExternalSystemArrayBase.hpp>
#include <samchon/protocol/IProtocol.hpp>

#include <vector>
#include <thread>

namespace samchon
{
namespace templates
{
namespace external
{
    template <class System = ExternalSystem>
    class ExternalSystemArray
        : public protocol::SharedEntityDeque<System>,
        public base::ExternalSystemArrayBase,
        public protocol::IProtocol
    {
    private:
        typedef protocol::SharedEntityDeque<System> super;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        ExternalSystemArray()
            : super()
        {
        };

        virtual ~ExternalSystemArray() = default;
        
    public:
        /* ---------------------------------------------------------
            ACCESSORS
        --------------------------------------------------------- */
        auto hasRole(const std::string &key) const -> bool
        {
            for (size_t i = 0; i < size(); i++)
                for (size_t j = 0; j < at(i)->size(); j++)
                    if (at(i)->at(j)->key() == key)
                        return true;

            return false;
        };

        auto getRole(const std::string &key) const -> std::shared_ptr<ExternalSystemRole>
        {
            for (size_t i = 0; i < size(); i++)
                for (size_t j = 0; j < at(i)->size(); j++)
                    if (at(i)->at(j)->key() == key)
                        return at(i)->at(j);

            throw std::out_of_range("No such key.");
        };

        virtual auto _Get_children() const -> std::vector<std::shared_ptr<ExternalSystem>>
        {
            std::vector<std::shared_ptr<ExternalSystem>> children(begin(), end());
            return children;
        };

        /* ---------------------------------------------------------
            MESSAGE CHAIN
        --------------------------------------------------------- */
        virtual void sendData(std::shared_ptr<protocol::Invoke> invoke)
        {
            std::vector<std::thread> threads;
            library::UniqueReadLock uk(getMutex());
            
            threads.reserve(this->size());
            for (size_t i = 0; i < size(); i++)
                threads.emplace_back(&ExternalSystem::sendData, at(i).get(), invoke);
            
            uk.unlock();
            for (auto it = threads.begin(); it != threads.end(); it++)
                it->join();
        };

        virtual void replyData(std::shared_ptr<protocol::Invoke> invoke) = 0;

        /* ---------------------------------------------------------
            EXPORTERS
        --------------------------------------------------------- */
        virtual auto TAG() const -> std::string override
        {
            return "systemArray";
        };
        virtual auto CHILD_TAG() const -> std::string override
        {
            return "system";
        };
    };
};
};
};