User.hpp

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

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

#include <vector>
#include <functional>
#include <thread>
#include <samchon/library/RWMutex.hpp>

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

    class User
        : public TreeMap<size_t, std::shared_ptr<Client>>,
        public virtual protocol::IProtocol
    {
        friend class Server;

    private:
        typedef TreeMap<size_t, std::shared_ptr<Client>> super;

        // RELATED OBJECTS
        Server *server;
        library::RWMutex mtx;
        
        // KEY
        std::string session_id;
        size_t sequence;

        // ACCOUTN
        std::string account;
        int authority;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        User(Server *server)
            : super()
        {
            this->server = server;
        };
        
        virtual ~User() = default;

    protected:
        virtual auto createClient() -> Client* = 0;

    private:
        void check_empty()
        {
            library::UniqueWriteLock uk(mtx);

            // NO CLIENT, THEN ERASE THIS USER.
            if (empty() == true)
                erase_user_function();
        };

    public:
        /* ---------------------------------------------------------
            ACCESSORS
        --------------------------------------------------------- */
        auto getServer() const -> Server*
        {
            return server;
        };

        auto getAccount() const -> std::string
        {
            return account;
        };

        auto getAuthority() const -> int
        {
            return authority;
        };

        auto getMutex() -> library::RWMutex& { return mtx; };
        auto getMutex() const -> const library::RWMutex& { return mtx; };

        void setAccount(const std::string &account, int authority)
        {
            if (this->account == account) // SAME WITH BEFORE
                return;
            else if (this->account.empty() == false) // ACCOUNT IS CHANGED
            {
                // ERASE FROM ORDINARY ACCOUNT_MAP
                library::UniqueWriteLock uk(*account_map_mtx);
                account_map->erase(this->account);
            }

            // SET
            this->account = account;
            this->authority = authority;

            // REGISTER TO ACCOUNT_MAP IN ITS SERVER
            library::UniqueWriteLock uk(*account_map_mtx);
            account_map->set(account, my_weak_ptr.lock());
        };

        void logout()
        {
            if (account.empty() == false)
                account_map->erase(account);

            account.clear();
        };

    public:
        /* ---------------------------------------------------------
            MESSAGE CHAIN
        --------------------------------------------------------- */
        virtual void sendData(std::shared_ptr<protocol::Invoke> invoke) override
        {
            std::vector<std::thread> threadArray;
            library::UniqueReadLock uk(mtx);

            threadArray.reserve(size());
            for (auto it = begin(); it != end(); it++)
                threadArray.emplace_back(&Client::sendData, it->second.get(), invoke);

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

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

    private:
        std::weak_ptr<User> my_weak_ptr;

        library::RWMutex *account_map_mtx;
        HashMap<std::string, std::shared_ptr<User>> *account_map;

        std::function<void()> erase_user_function;
    };
};
};
};