Client.hpp

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

#include <samchon/protocol/IProtocol.hpp>
#include <samchon/templates/service/Service.hpp>

#include <samchon/protocol/WebClientDriver.hpp>

#define KEEP_CLIENT_ALIVE auto &__keeper = __keep_alive();

namespace samchon
{
namespace templates
{
namespace service
{
    class Server;
    class User;

    class Client
        : public virtual protocol::IProtocol
    {
        friend class Server;

    private:
        // RELATED OBJECTS
        User *user;
        
        std::shared_ptr<protocol::WebClientDriver> driver;
        std::unique_ptr<Service> service;

        // KEY
        size_t no;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        Client(User *user, std::shared_ptr<protocol::WebClientDriver> driver)
        {
            this->user = user;
            this->driver = driver;
        };

        virtual ~Client() = default;

    protected:
        virtual auto createService(const std::string &) -> Service* = 0;

        auto __keep_alive() const -> std::pair<std::shared_ptr<User>, std::shared_ptr<Client>>
        {
            return std::make_pair(user_weak_ptr.lock(), my_weak_ptr.lock());
        };

    public:
        /* ---------------------------------------------------------
            ACCESSORS
        --------------------------------------------------------- */
        auto getUser() const -> User*
        {
            return user;
        };

        auto getService() const -> Service*
        {
            return service.get();
        };

        auto getNo() const -> size_t
        {
            return no;
        };

        void changeService(const std::string &path)
        {
            service.reset(createService(path));
        };

        void changeService(Service *obj)
        {
            service.reset(obj);

            service->user_weak_ptr = user_weak_ptr;
            service->client_weak_ptr = my_weak_ptr;
        };

    public:
        /* ---------------------------------------------------------
            MESSAGE CHAIN
        --------------------------------------------------------- */
        virtual void sendData(std::shared_ptr<protocol::Invoke> invoke) override
        {
            driver->sendData(invoke);
        };

        virtual void replyData(std::shared_ptr<protocol::Invoke> invoke)
        {
            ((protocol::IProtocol*)user)->replyData(invoke);
            service->replyData(invoke);
        };

    private:
        std::weak_ptr<User> user_weak_ptr;
        std::weak_ptr<Client> my_weak_ptr;
    };
};
};
};