ExternalSystem.hpp

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

#include <samchon/protocol/SharedEntityDeque.hpp>
#   include <samchon/templates/external/ExternalSystemRole.hpp>
#include <samchon/templates/external/base/ExternalSystemBase.hpp>
#include <samchon/protocol/IProtocol.hpp>

#include <samchon/templates/external/base/ExternalSystemArrayBase.hpp>
#include <samchon/templates/external/base/ExternalServerBase.hpp>

#include <samchon/protocol/ClientDriver.hpp>

namespace samchon
{
namespace templates
{
namespace external
{
    class ExternalSystem
        : public protocol::SharedEntityDeque<ExternalSystemRole>,
        public base::ExternalSystemBase,
        public virtual protocol::IProtocol
    {
    private:
        typedef protocol::SharedEntityDeque<ExternalSystemRole> super;

    protected:
        std::shared_ptr<protocol::Communicator> communicator_;
    
        std::string name;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        ExternalSystem()
            : super()
        {
            this->system_array_ = nullptr;
        }

        ExternalSystem(base::ExternalSystemArrayBase *systemArray)
            : super()
        {
            this->system_array_ = systemArray;
        };

        ExternalSystem(base::ExternalSystemArrayBase *systemArray, std::shared_ptr<protocol::ClientDriver> driver)
        {
            this->communicator_ = driver;
        };

        virtual ~ExternalSystem() = default;

        virtual void construct(std::shared_ptr<library::XML> xml) override
        {
            name = xml->fetchProperty("name");

            base::ExternalServerBase *server = dynamic_cast<base::ExternalServerBase*>(this);
            if (server != nullptr)
            {
                server->ip = xml->getProperty<std::string>("ip");
                server->port = xml->getProperty<int>("port");
            }

            super::construct(xml);
        };

    public:
        /* ---------------------------------------------------------
            ACCESSORS
        --------------------------------------------------------- */    
        virtual auto key() const -> std::string
        {
            return name;
        };

        auto getName() const -> std::string
        {
            return name;
        };

    public:
        /* ---------------------------------------------------------
            NETWORK & MESSAGE CHAIN
        --------------------------------------------------------- */
        void close()
        {
            communicator_->close();
        };

        virtual void sendData(std::shared_ptr<protocol::Invoke> invoke) override
        {
            communicator_->sendData(invoke);
        };

        virtual void replyData(std::shared_ptr<protocol::Invoke> invoke) override
        {
            // SHIFT TO ROLES
            for (size_t i = 0; i < size(); i++)
                at(i)->replyData(invoke);

            // SHIFT TO SYSTEM_ARRAY
            ((IProtocol*)system_array_)->replyData(invoke);
        };

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

        virtual auto toXML() const -> std::shared_ptr<library::XML> override
        {
            std::shared_ptr<library::XML> &xml = super::toXML();
            xml->setProperty("name", name);

            const base::ExternalServerBase *server = dynamic_cast<const base::ExternalServerBase*>(this);
            if (server != nullptr)
            {
                xml->setProperty("ip", server->ip);
                xml->setProperty("port", server->port);
            }

            return xml;
        };
    };
};
};
};