DSInvokeHistory.hpp

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

#include <samchon/templates/slave/InvokeHistory.hpp>

#include <samchon/templates/distributed/base/DistributedSystemArrayBase.hpp>
#include <samchon/templates/external/base/ExternalSystemBase.hpp>

namespace samchon
{
namespace templates
{
namespace distributed
{
    class DistributedSystem;
    class DistributedProcess;

    class DSInvokeHistory
        : public slave::InvokeHistory
    {
        friend class DistributedSystem;

    private:
        typedef slave::InvokeHistory super;

        DistributedSystem *system_;
        DistributedProcess *process_;
        double weight_;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        DSInvokeHistory(DistributedSystem *system)
            : super()
        {
            this->system_ = system;
        };

        DSInvokeHistory(DistributedSystem *system, DistributedProcess *process, std::shared_ptr<protocol::Invoke> invoke, double weight)
            : super(invoke)
        {
            this->system_ = system;
            this->process_ = process;
            this->weight_ = weight;
        };

        virtual ~DSInvokeHistory() = default;

        virtual void construct(std::shared_ptr<library::XML> xml) override
        {
            super::construct(xml);

            if (xml->hasProperty("process") == false)
            {
                process_ = nullptr;
                return;
            }

            std::string &process_name = xml->getProperty("process");
            base::DistributedSystemArrayBase *system_array = ((external::base::ExternalSystemBase*)system)->getSystemArray<base::DistributedSystemArrayBase>();

            if (system_array->hasProcess(process_name) == true)
                process_ = system_array->getProcess(process_name).get();
            else
                process_ = nullptr;
        };

        /* ---------------------------------------------------------
            ACCESSORS
        --------------------------------------------------------- */
        auto getSystem() const -> DistributedSystem*
        {
            return system_;
        };

        auto getProcess() const -> DistributedProcess*
        {
            return process_;
        };

        auto getWeight() const -> double
        {
            return weight_;
        };

        /* ---------------------------------------------------------
            EXPORTERS
        --------------------------------------------------------- */
        virtual auto toXML() const -> std::shared_ptr<library::XML> override
        {
            std::shared_ptr<library::XML> &xml = super::toXML();
            if (process_ != nullptr)
                xml->setProperty("process", ((protocol::Entity<std::string>*)process_)->key());

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