XML.hpp

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

#include <samchon/HashMap.hpp>
#include <samchon/library/XMLList.hpp>

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

namespace std
{
    template<class T, class _Alloc> class list;
};
namespace samchon
{
namespace library
{
    class SAMCHON_FRAMEWORK_API XML
        : public HashMap<std::string, std::shared_ptr<XMLList>>
    {
    private:
        typedef HashMap<std::string, std::shared_ptr<XMLList>> super;

        std::string tag;

        std::string value;

        HashMap<std::string, std::string> propertyMap;

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

        XML(const XML &);

        XML(XML &&);

        XML(WeakString);

    private:
        XML(XML*, WeakString &);

        void construct(WeakString &);
        void constructKey(WeakString &);
        void constructProperty(WeakString &);
        auto constructValue(WeakString &) -> bool;
        void constructChildren(WeakString &);

    public:
        void push_back(const WeakString &);

        void push_back(const std::shared_ptr<XML>);

        void addAllProperty(const std::shared_ptr<XML>);

        /* -----------------------------------------------------------
            SETTERS
        ----------------------------------------------------------- */
        void setTag(const std::string &);

        template <typename T>
        void setValue(const T &val)
        {
            std::stringstream sstream;
            sstream << val;

            this->value = std::move(sstream.str());
        };
        template<> void setValue(const std::string &val)
        {
            this->value = val;
        };
        template<> void setValue(const WeakString &val)
        {
            this->value = val.str();
        };

        template <typename T>
        void insertValue(const std::string &tag, const T &val)
        {
            std::shared_ptr<XML> xml(new XML());
            xml->setTag(tag);
            xml->setValue(val);

            push_back(xml);
        };

        template<typename T>
        void setProperty(const std::string &key, const T &val)
        {
            std::stringstream sstream;
            sstream << val;

            propertyMap.set(key, sstream.str());
        };
        template<> void setProperty(const std::string &key, const std::string &val)
        {
            propertyMap.set(key, val);
        };
        template<> void setProperty(const std::string &key, const WeakString &val)
        {
            propertyMap.set(key, val.str());
        };

        void eraseProperty(const std::string&);

        void clearProperties();

        /* -----------------------------------------------------------
            GETTERS
        ----------------------------------------------------------- */
    public:
        auto getTag() const->std::string;

        template<class T = std::string> auto getValue() const -> T
        {
            std::stringstream sstream;
            sstream << this->value;

            T val;
            sstream >> val;

            return std::move(val);
        };

        template<> auto getValue() const -> std::string
        {
            return value;
        };
        template<> auto getValue() const -> WeakString
        {
            return value;
        };

        template<class T = std::string> auto getProperty(const std::string &key) const -> T
        {
            std::stringstream sstream;
            sstream << propertyMap.get(key);

            T val;
            sstream >> val;

            return std::move(val);
        };

        template<> auto getProperty(const std::string &key) const -> std::string
        {
            return propertyMap.get(key);
        };
        template<> auto getProperty(const std::string &key) const -> WeakString
        {
            return propertyMap.get(key);
        };

        auto hasProperty(const std::string &) const -> bool;

        auto getPropertyMap() const -> const HashMap<std::string, std::string>&;

        /* -----------------------------------------------------------
            FILTERS
        ----------------------------------------------------------- */
    private:
        auto calcMinIndex(const std::vector<size_t>&) const->size_t;

        auto encodeValue(const WeakString &) const->std::string;
        auto decodeValue(const WeakString &) const->std::string;
        auto encodeProperty(const WeakString &) const->std::string;
        auto decodeProperty(const WeakString &) const->std::string;

        /* -----------------------------------------------------------
            EXPORTERS
        ----------------------------------------------------------- */
    public:
        auto toString(size_t level = 0) const->std::string;
    };

    SAMCHON_FRAMEWORK_EXTERN template class SAMCHON_FRAMEWORK_API std::shared_ptr<XML>;
    SAMCHON_FRAMEWORK_EXTERN template class SAMCHON_FRAMEWORK_API HashMap<std::string, std::shared_ptr<XMLList>>;
    SAMCHON_FRAMEWORK_EXTERN template class SAMCHON_FRAMEWORK_API HashMap<std::string, std::string>;
};
};