Master.hpp

#pragma once
#include <samchon/protocol/master/ParallelClientArray.hpp>

#include <samchon/example/interaction/ChiefDriver.hpp>
#include <samchon/example/interaction/SlaveDriver.hpp>
#include <samchon/protocol/Invoke.hpp>

#include <array>
#include <iostream>
#include <mutex>

namespace samchon
{
namespace example
{
namespace interaction
{
    using namespace std;

    using namespace library;
    using namespace protocol;

    class Master
        : public master::ParallelClientArray
    {
    private:
        typedef master::ParallelClientArray super;

    protected:
        unique_ptr<ChiefDriver> chiefDriver;

        mutex mtx;

        size_t optimized;

    public:
        /* ------------------------------------------------------------
        CONSTRUCTORS
        ------------------------------------------------------------ */
        Master(int port)
            : super()
        {
            this->port = port;
            chiefDriver.reset(new ChiefDriver(this, port + 10));

            optimized = 0;
        };
        virtual ~Master() = default;

        virtual void start() override
        {
            array<thread, 2> threadArray =
            {
                thread([this]()
                {
                    super::start();
                }),
                    thread([this]()
                {
                    chiefDriver->open();
                })
            };

            for (auto it = threadArray.begin(); it != threadArray.end(); it++)
                it->join();
        };

    protected:
        virtual auto createChild(shared_ptr<XML>) -> ExternalSystem* override
        {
            return new SlaveDriver();
        };

    public:
        /* ------------------------------------------------------------
            INVOKE MESSAGE CHAIN
        ------------------------------------------------------------ */
        virtual void replyData(shared_ptr<Invoke> invoke) override
        {
            if (invoke->getListener() == "optimize")
                optimize(invoke->at(0)->getValueAsXML());
            else if (invoke->getListener() == "replyOptimization")
                replyOptimization(invoke->at(0)->getValueAsXML());
        };

    protected:
        virtual void addClient(Socket *socket) override
        {
            cout << "A client has connected." << endl;

            super::addClient(socket);
        };

        virtual void optimize(shared_ptr<XML> xml)
        {
            cout << "----------------------------------------------------------------------------" << endl;
            cout << "   OPTIMIZE" << endl;
            cout << "----------------------------------------------------------------------------" << endl;

            optimized = 0;
        };

        virtual void replyOptimization(shared_ptr<XML> xml) = 0;
    };
};
};
};