JSONParser.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: JSONParser
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Scanner.h>
#include <NDEVR/String.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/Vertex.h>
#include <NDEVR/StringView.h>
#include <NDEVR/Time.h>
namespace NDEVR
{
    class TranslatedString;

    template<class t_type>
    class JSONToStringHelper
    {
    public:
        static t_type Convert(const String& value)
        {
            return value.getAs<t_type>();
        }
    };

    template<class t_type>
    class JSONToStringHelper<Angle<t_type>>
    {
    public:
        static Angle<t_type> Convert(const String& value)
        {
            return Angle<t_type>(DEGREES, value.getAs<fltp08>());
        }
    };

    template<>
    class JSONToStringHelper<String>
    {
    public:
        static StringView Convert(const String& value)
        {
            return StringView(value);
        }
    };

    template<>
    class JSONToStringHelper<Time>
    {
    public:
        static Time Convert(const String& value)
        {
            //There are 3 different types of times we support. As JSON does not specify a
            //time format each of these could be valid. We will do some tests to guess which to use
            if (value.contains('.'))//Option 1) JavaScript built-in JSON object
                return Time(value, false, "YYYY/MM/DDTHH:mm:ss.fffZ");
            else if (value.contains('T'))//Option 2) JavaScript built-in JSON object with no millisecond
                return Time(value, false, "YYYY/MM/DDTHH:mm:ss");
            uint04 sub_value = value.indexOf("Date(");//Option 3) date sub value expressed as seconds)
            if (IsValid(sub_value))
            {
                return Time(value.substr(sub_value + 5).getAs<uint08>() * Time::SECOND);
            }
            Time time_val = value.getAs<Time>();
            lib_assert(IsValid(time_val), "Could not parse time value");
            return time_val;//Return an invalid time as we were unable to parse
        }
    };

    class NDEVR_BASE_API JSONNode
    {
        static const uint04 s_number_of_decimals = 10; 
    public:
        enum NodeType
        {
            e_number   
            , e_array  
            , e_bool   
            , e_object 
            , e_node   
            , e_root   
        };
    public:

        JSONNode();

    protected:
        JSONNode(const StringView& name);
    public:
        JSONNode(const JSONNode& node);

        JSONNode(JSONNode&& node) noexcept;

        JSONNode(Scanner& scan);
        JSONNode(const String& node, const StringView& json_string);
        JSONNode(File& file);

        ~JSONNode();

        NodeType type() const;

        void write(String& stream) const;
        void writeValue(String& stream) const;

        void write(File& file);

        void write(std::ostream& file);

        void writePretty(String& stream, const uint04 tab_indention = 0) const;
        void writePretty(File& file);
        void writePretty(std::ostream& file);
        template<class t_type>
        decltype(auto) getAs() const
        {
            return JSONToStringHelper<t_type>::Convert(m_value);
        }

        const JSONNode& get(const StringView& child_node) const
        {
            return *m_json_children[child_node];
        }

        const JSONNode& operator[](const StringView& child_node) const
        {
            return *m_json_children[child_node];
        }

        JSONNode& operator[](const StringView& child_node)
        {
            auto iter = m_json_children.find(child_node);
            if (iter == m_json_children.end())
            {
                JSONNode* node = new JSONNode(child_node);
                m_sorted_json_children.add(node);
                iter = m_json_children.insert(iter, { node->nodeName(), node });
            }
            return *iter.value();
        }

        JSONNode& operator[](const uint04& child_idx)
        {
            return *m_sorted_json_children[child_idx];
        }

        const JSONNode& operator[](const uint04& child_idx) const
        {
            return *m_sorted_json_children[child_idx];
        }

        const Buffer<JSONNode*>& children() const
        {
            return m_sorted_json_children;
        }

        bool hasNode(const StringView& child_node) const
        {
            return m_json_children.hasKey(child_node);
        }

        const String& nodeName() const
        {
            return m_name;
        }

        template<class t_type>
        void setOrClearIfDefault(const StringView& child_node, const t_type& value, const t_type& default_value)
        {
            if (AreSame(value, default_value))
                remove(child_node);
            else
                (*this)[child_node] = value;
        }

        template<class t_type>
        t_type get(const StringView& child_node, const t_type& default_value) const
        {
            auto iter = m_json_children.find(child_node);
            if (iter != m_json_children.end())
                return iter.value()->getAs<t_type>();
            else
                return default_value;
        }

        template<class t_type>
        bool getIfExists(const StringView& child_node, t_type& value) const
        {
            auto iter = m_json_children.find(child_node);
            if (iter == m_json_children.end())
                return false;
            value = iter.value()->getAs<t_type>();
            return true;
        }

        void remove(const StringView& child_node);
        JSONNode& createChildNode(NodeType type = NodeType::e_node)
        {
            return createChildNode(StringView(), type);
        }

        JSONNode& createChildNode(const StringView& child_node, NodeType type);
        JSONNode& operator=(const JSONNode& node)
        {
            m_value = node.m_value;
            if (node.m_type == e_root)
                m_type = e_node;//convert root to node
            else
                m_type = node.m_type;
            for (const JSONNode* iter : m_sorted_json_children)
                delete iter;
            m_sorted_json_children.clear();
            m_json_children.clear();
            for (const auto& iter : node.m_sorted_json_children)
            {
                JSONNode* new_node = new JSONNode(*iter);
                m_sorted_json_children.add(new_node);
                auto json_child = m_json_children.find(new_node->nodeName());
                if (json_child == m_json_children.end())
                    m_json_children.insert(json_child, { new_node->nodeName(), new_node });
            }
            return *this;
        }
 

        JSONNode& operator=(const StringView& value)
        {
            m_type = e_object;
            m_value = value;
            return *this;
        }

        template<class t_type>
        JSONNode& operator=(const Angle<t_type>& value)
        {
            m_type = e_object;
            m_value.setFrom(value.template as<DEGREES>());
            return *this;
        }

        JSONNode& operator=(const Time& time)
        {
            m_type = e_object;
            m_value = time.getAsString(false, "YYYY/MM/DDTHH:mm:ss.fffZ");;
            return *this;
        }

        template<class t_type, class t_allocator>
        JSONNode& operator=(const Buffer<t_type, t_allocator>& buffer)
        {
            m_type = e_array;
            m_value.clear();
            m_value.append(buffer[0]);
            for (uint01 i = 1; i < buffer.size(); i++)
            {
                m_value.append(',');
                m_value.append(buffer[i]);
            }
            m_value.setFrom(buffer);
            return *this;
        }

        template<class String>
        JSONNode& operator=(const Buffer<String>& buffer)
        {
            m_type = e_array;
            m_value.clear();
            m_value.append("\"");
            m_value.append(buffer[0]);
            for (uint01 i = 1; i < buffer.size(); i++)
            {
                m_value.append("\",\"");
                m_value.append(buffer[i]);
            }
            m_value.append("\"");
            return *this;
        }

        template<class String>
        JSONNode& operator=(const Buffer<StringView>& buffer)
        {
            m_type = e_array;
            m_value.clear();
            m_value.append("\"");
            m_value.append(buffer[0]);
            for (uint01 i = 1; i < buffer.size(); i++)
            {
                m_value.append("\",\"");
                m_value.append(buffer[i]);
            }
            m_value.append("\"");
            return *this;
        }

        template<uint01 t_dims, class t_type>
        JSONNode& operator=(const Vector<t_dims, t_type>& buffer)
        {
            setVector(buffer);
            return *this;
        }

        template<uint01 t_dims, class t_type>
        JSONNode& operator=(const Vertex<t_dims, t_type>& buffer)
        {
            setVector(buffer);
            return *this;
        }

        template<uint01 t_dims, class t_type>
        JSONNode& operator=(const Ray<t_dims, t_type>& buffer)
        {
            setVector(buffer);
            return *this;
        }

        [[nodiscard]] bool isEmpty() const
        {
            return m_value.size() == 0 && m_json_children.size() == 0;
        }

        template<class t_type>
        JSONNode& operator=(const t_type& value)
        {
            if (ObjectInfo<t_type>::Number)
                m_type = e_number;
            else if (ObjectInfo<t_type>::Boolean)
                m_type = e_bool;
            else if (ObjectInfo<t_type>::Vector)
                m_type = e_array;
            else if (ObjectInfo<t_type>::Color)//An RGBColor is converted into an array of integers {red, green, blue, alpha}
                m_type = e_array;
            else
                m_type = e_object;
            m_value.setFrom(value);
            return *this;
        }

        uint04 size()
        {
            return cast<uint04>(m_json_children.size());
        }

        [[nodiscard]] decltype(auto) begin()
        {
            return m_json_children.begin();
        }

        [[nodiscard]] decltype(auto) begin() const
        {
            return m_json_children.begin();
        }

        [[nodiscard]] decltype(auto) end()
        {
            return m_json_children.end();
        }

        [[nodiscard]] decltype(auto) end() const
        {
            return m_json_children.end();
        }

        static JSONNode ParseYAML(Scanner& scan);
        
    protected:
        bool parseJSON(Scanner& scan);
        bool parseJSONContent(char start, Scanner& scan);

        bool parseYAMLContent(uint04 indentention, Scanner& scan);
        void parseYAMLContent(StringView value);

        void readChildrenNodes(Scanner& scan);

        void readData(Scanner& scan);

        void readArray(Scanner& scan);

        static void WriteTabs(String& stream, uint04 tab_indention);
        static void ConvertToJSONString(String& string);
        static void ConvertFromJSONString(String& string);
    protected:
        template<uint01 t_dims, class t_type>
        void setVector(const Vector<t_dims, t_type>& buffer)
        {
            m_type = e_array;
            m_value.clear();
            m_value.append(buffer[0]);
            for (uint01 i = 1; i < t_dims; i++)
            {
                m_value.append(',');
                m_value.append(buffer[i]);
            }
        }

        static TranslatedString UnexpectedCharErrorString(char current_char, const Scanner& scan);
        static TranslatedString DuplicateChildErrorString(const StringView& child, const Scanner& scan);
        static TranslatedString BadChildErrorString(const Scanner& scan);
    protected:
        Buffer<JSONNode*> m_sorted_json_children; 
        Dictionary<StringView, JSONNode*> m_json_children; 
        const String m_name; 
        String m_value; 
        NodeType m_type; 
    private:
 
    };
 
}