repo_property_tree.h

#pragma once

#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/algorithm/string/replace.hpp>
//#include <boost/property_tree/json_parser.hpp>
#include "json_parser.h"
#include "../core/model/repo_node_utils.h"

namespace repo{
    namespace lib{
        class PropertyTree
        {
        public:
            PropertyTree();
            PropertyTree(const bool &enableJSONWorkAround);
            ~PropertyTree();

            void addArrayObjects(
                const std::string               &label,
                const std::vector<PropertyTree> &value)
            {
                boost::property_tree::ptree arraytree;
                for (size_t i = 0; i < value.size(); ++i)
                {
                    arraytree.push_back(std::make_pair("", value[i].tree));
                }

                tree.add_child(label, arraytree);
            }

            template <typename T>
            void addFieldAttribute(
                const std::string &label,
                const std::string &attribute,
                const T &value
                )
            {
                addFieldAttribute(label, attribute, boost::lexical_cast<std::string>(value));
            }

            template <typename T>
            void addFieldAttribute(
                const std::string &label,
                const std::string &attribute,
                const std::vector<T> &value,
                const bool        &useDelimiter = true
                )
            {
                std::stringstream ss;
                for (uint32_t i = 0; i < value.size(); ++i)
                {
                    ss << value[i];
                    if (useDelimiter && i != value.size() - 1)
                    {
                        ss << ",";
                    }
                    else
                        ss << " ";
                }
                std::string val = ss.str();
                addFieldAttribute(label, attribute, val);
            }

            template <typename T>
            void addToTree(
                const std::string           &label,
                const T                     &value)
            {
                if (label.empty())
                    tree.put(label, value);
                else
                    tree.add(label, value);
            }

            template <std::size_t N>
            void addToTree(
                const std::string           &label,
                const char(&value)[N])
            {
                addToTree(label, std::string(value));
            }

            template <typename T>
            void addToTree(
                const std::string           &label,
                const std::vector<T>        &value,
                const bool                  &join = true)
            {
                if (join)
                {
                    boost::property_tree::ptree arrayTree;
                    for (const auto &child : value)
                    {
                        PropertyTree childTree;
                        childTree.addToTree("", child);
                        arrayTree.push_back(std::make_pair("", childTree.tree));
                    }

                    tree.add_child(label, arrayTree);
                }
                else
                {
                    std::stringstream ss;
                    for (size_t i = 0; i < value.size(); ++i)
                    {
                        ss << boost::lexical_cast<std::string>(value[i]);
                        if (i != value.size() - 1)
                            ss << " ";
                    }

                    std::string valueInStr = ss.str();
                    addToTree(label, valueInStr);
                }
            }

            void disableJSONWorkaround()
            {
                hackStrings = false;
            }

            void mergeSubTree(
                const std::string   &label,
                const PropertyTree  &subTree)
            {
                tree.add_child(label, subTree.tree);
            }

            void write_json(
                std::iostream &stream
                ) const
            {
                boost::property_tree::write_json(stream, tree, false);
            }

            void write_xml(
                std::iostream &stream
                ) const
            {
                std::stringstream ss;
                boost::property_tree::write_xml(ss, tree);
                std::string stringxml = ss.str();
                //revert the xml_parser's utility where it swaps tabs and newlines with codes
                boost::replace_all(stringxml, "&#9;", "\t");
                boost::replace_all(stringxml, "&#10;", "\n");
                stream << stringxml;
            }

        private:
            bool hackStrings;
            boost::property_tree::ptree tree;

            std::string sanitizeStr(const std::string &value);

            int findSpecialWords(
                const std::string &value,
                const int         &start);

            int findBackSlash(
                const std::string &value,
                const int         &start);
        };
        // Template specialization
        template <>
        void PropertyTree::addToTree<repo_vector_t>(
            const std::string           &label,
            const repo_vector_t         &value);

        template <>
        void PropertyTree::addToTree<std::string>(
            const std::string           &label,
            const std::string           &value);

        template <>
        void PropertyTree::addToTree<repoUUID>(
            const std::string           &label,
            const repoUUID              &value);

        template <>
        void PropertyTree::addToTree(
            const std::string                &label,
            const std::vector<PropertyTree>  &value,
            const bool                       &join);

        template <>
        void PropertyTree::addFieldAttribute(
            const std::string &label,
            const std::string &attribute,
            const std::string &value
            );

        template <>
        void PropertyTree::addFieldAttribute(
            const std::string  &label,
            const std::string  &attribute,
            const repo_vector_t &value
            );
    }
}