InvokeParameter.hpp

#pragma once
#include <samchon/protocol/Entity.hpp>

#include <sstream>
#include <samchon/ByteArray.hpp>
#include <samchon/WeakString.hpp>

namespace samchon
{
namespace protocol
{
    class Invoke;

    class InvokeParameter
        : public virtual Entity<>
    {
        friend class Invoke;

    protected:
        typedef Entity<std::string> super;

        std::string name;

        std::string type;

        std::string str;

        std::shared_ptr<library::XML> xml;

        ByteArray byte_array;

    public:
        /* ----------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------- */
        InvokeParameter()
        {
        };

        InvokeParameter(const std::string &name, const std::string &type, const std::string &val)
        {
            this->name = name;
            this->type = type;
            this->str = val;
        };

        template <typename T>
        InvokeParameter(const std::string &name, const T &val)
        {
            this->name = name;

            construct_by_varadic_template(val);
        };

        InvokeParameter(const std::string &name, const char *ptr)
        {
            this->name = name;
            this->type = "string";

            this->str = ptr;
        };

        //MOVE CONSTRUCTORS
        InvokeParameter(const std::string &name, std::string &&str)
        {
            this->name = name;
            this->type = "string";

            this->str = move(str);
        };

        InvokeParameter(const std::string &name, ByteArray &&byte_array)
        {
            this->name = name;
            this->type = "ByteArray";

            this->byte_array = move(byte_array);
        };

        virtual ~InvokeParameter() = default;

        virtual void construct(std::shared_ptr<library::XML> xml) override
        {
            if (xml->hasProperty("name") == true)
                this->name = xml->getProperty("name");
            else
                this->name = "";

            this->type = xml->getProperty("type");

            if (type == "XML")
            {
                if (xml->empty())
                    this->xml = nullptr;
                else
                    this->xml = xml->begin()->second->at(0);
            }
            else if (type == "ByteArray")
            {
                size_t size = xml->getValue<size_t>();

                byte_array.reserve(size);
            }
            else
                this->str = xml->getValue();
        };

        auto byteArrayCapacity() const -> size_t
        {
            return byte_array.capacity();
        };

        void setByteArray(ByteArray &&ba)
        {
            byte_array = move(ba);
        };

    protected:
        template <typename T>
        void construct_by_varadic_template(const T &val)
        {
            this->type = "number";

            std::stringstream sstream;
            sstream << val;

            this->str = move(sstream.str());
        };
        template<> void construct_by_varadic_template(const std::string &str)
        {
            this->type = "string";
            this->str = str;
        };
        template<> void construct_by_varadic_template(const WeakString &wstr)
        {
            this->type = "string";
            this->str = wstr.str();
        };
        template<> void construct_by_varadic_template(const ByteArray &byte_array)
        {
            this->type = "ByteArray";
            this->byte_array = byte_array;
        };

        template<> void construct_by_varadic_template(const std::shared_ptr<library::XML> &xml)
        {
            this->type = "XML";
            this->xml = xml;
        };

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

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

        auto getType() const->std::string
        {
            return type;
        };

        template<typename T> auto getValue() const -> T
        {
            double val = std::stod(str);

            return (T)val;
        };
        template<> auto getValue() const -> std::string
        {
            return str;
        };
        template<> auto getValue() const -> WeakString
        {
            return str;
        };
        template<> auto getValue() const -> std::shared_ptr<library::XML>
        {
            return xml;
        };
        template<> auto getValue() const -> ByteArray
        {
            return byte_array;
        };

        auto getValueAsXML() const -> std::shared_ptr<library::XML>
        {
            return xml;
        };

        template <typename T> auto referValue() const -> const T&;
        template<> auto referValue() const -> const std::string&
        {
            return str;
        };
        template<> auto referValue() const -> const ByteArray&
        {
            return byte_array;
        };

        template <typename T> auto moveValue() -> T;
        template<> auto moveValue() -> std::string
        {
            return move(str);
        };
        template<> auto moveValue() -> ByteArray
        {
            return move(byte_array);
        };

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

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

            if (name.empty() == false)
                xml->setProperty("name", name);
            xml->setProperty("type", type);

            if (type == "XML")
                xml->push_back(this->xml);
            else if (type == "ByteArray")
                xml->setValue(byte_array.size());
            else
                xml->setValue(str);

            return xml;
        };
    };
};
};