InvokeParameter.hpp

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

#include <samchon/protocol/Entity.hpp>

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

namespace samchon
{
namespace protocol
{
    class Invoke;

    class SAMCHON_FRAMEWORK_API InvokeParameter
        : public virtual Entity
    {
        friend class Invoke;

    protected:
        typedef Entity super;

        std::string name;

        std::string type;

        std::string str;

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

        ByteArray byteArray;

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

        InvokeParameter(const std::string &, const std::string &, const std::string &);

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

            construct_by_varadic_template(val);
        };

        InvokeParameter(const std::string &, const char*);

        //MOVE CONSTRUCTORS
        InvokeParameter(const std::string &, std::string &&);

        InvokeParameter(const std::string &, ByteArray &&);

        virtual ~InvokeParameter() = default;

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

        auto reservedByteArraySize() const->size_t;
        void setByteArray(ByteArray &&);

    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 &byteArray)
        {
            this->type = "ByteArray";
            this->byteArray = byteArray;
        };

        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;

        auto getName() const->std::string;

        auto getType() const->std::string;

        template<typename T> auto getValue() const -> T
        {
            std::stringstream sstream;
            sstream << this->str;

            T val;
            sstream >> val;

            return 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 byteArray;
        };

        auto getValueAsXML() const->std::shared_ptr<library::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 byteArray;
        };

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

    public:
        /* ----------------------------------------------------------
            EXPORTERS
        ---------------------------------------------------------- */
        virtual auto TAG() const->std::string override;

        virtual auto toXML() const->std::shared_ptr<library::XML> override;

        auto toSQL() const->std::string;
    };
};
};