JSONParser.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
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/Time.h>
 /**--------------------------------------------------------------------------------------------------
 Namespace: Parke
 Namespace that wraps all Logic created by Tyler Parke
 *-----------------------------------------------------------------------------------------------**/
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 const String& Convert(const String& value)
        {
            return value;
        }
    };
    template<>
    class JSONToStringHelper<Time>
    {
    public:
        /**--------------------------------------------------------------------------------------------------
        \brief Template specialization for time, as the format for time in JSON is not entirely specified, so we
        make some guesses.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        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 (!isNaN(sub_value))
            {
                return Time(value.substr(sub_value + 5).getAs<uint08>() * Time::SECOND);
            }
            Time time_val = value.getAs<Time>();
            lib_assert(!isNaN(time_val), "Could not parse time value");
            return time_val;//Return an invalid time as we were unable to parse
        }
    };
    /**--------------------------------------------------------------------------------------------------
    Class: JSONNode
 
    \brief JavaScript Object Notation or JSON is an open - standard file format that uses human - readable text
    to transmit data objects consisting of attribute–value pairs and array data types(or any other
    serializable value).
    
    It is a very common data format used for asynchronous browser–server communication,
    including as a replacement for XML in some AJAX - style systems.
 
    The JSONNode class serves as a container for data and it's children. Includes options to read and write
    from streams and files.
 
    Author: Tyler Parke
 
    Date: 2017-11-13
    *-----------------------------------------------------------------------------------------------**/
    class NDEVR_BASE_API JSONNode
    {
        static const uint04 s_number_of_decimals = 10;//default number of decimals to write
    public:
        enum NodeType
        {
            e_number // Stores a number (May be integer or floating point)
            , e_array  // Stores an array of values
            , e_bool   // Stores boolean true/false
            , e_object // Stores an object, which has data, but is not a number type 
            , e_node   // Is a node, storing a number of children JSON nodes
            , e_root   // Is a root node, meaning it has no parent
        };
    public:
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode::JSONNode(const String& name)
 
        Creates a root JSON node
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        JSONNode();
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode::JSONNode(const String& name)
 
        Creates a JSONNode with a given name
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
    protected:
        JSONNode(const String& name);
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode::JSONNode(const JSONNode& node)
 
        Very basic copy constructor.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
    public:
        JSONNode(const JSONNode& node);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode::JSONNode(const JSONNode&& node)
 
        Very basic move constructor.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        JSONNode(JSONNode&& node) noexcept;
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode::JSONNode(Scanner& scan)
 
        Creates a JSONNode by parsing it from the scanner. Scanner should be at the start of the file or
        stream just before the opening '{'
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        JSONNode(Scanner& scan);
        JSONNode(const String& node, const String& json_string);
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode::JSONNode(File& scan)
 
        Creates a JSONNode by parsing it from the File.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        JSONNode(File& file);
 
        ~JSONNode();
 
        /**--------------------------------------------------------------------------------------------------
        Fn: NodeType JSONNode::type() const
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Returns: The type of the node which will give a hint as to how the contents should be written to
        a file, or interpretted by the program
        *-----------------------------------------------------------------------------------------------**/
        NodeType type() const;
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::write(String& stream) const
 
        A no frills write routine. Useful for writing to a file.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        stream - The stream where you want the JSON node to be written
        *-----------------------------------------------------------------------------------------------**/
        void write(String& stream) const;
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::write(File& file)
 
        \brief Writes the JSON structure out to a file with no frills. Same as write(String&) but for files.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        file - The file where you want the JSON node to be written
        *-----------------------------------------------------------------------------------------------**/
        void write(File& file);
 
        void write(std::ostream& file);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::writePretty(String& stream, const uint04 tab_indention = 0) const
 
        \brief Same as write, but adds tabs and new lines to make it easier to read, though will result in larger
        file.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        stream - The stream where you want the JSON node to be written
        tab_indention - The number of tabs to place before writing data
        *-----------------------------------------------------------------------------------------------**/
        void writePretty(String& stream, const uint04 tab_indention = 0) const;
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::writePretty(File& file)
 
        \brief Writes our structure out to a file using tabs and new lines. Same as writePretty(String&) but for files.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        file - The file where you want the JSON node to be written
        *-----------------------------------------------------------------------------------------------**/
        void writePretty(File& file);
        void writePretty(std::ostream& file);
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::getAs()
 
        Returns this object as the type specified.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        template<class t_type>
        decltype(auto) getAs() const
        {
            return JSONToStringHelper<t_type>::Convert(m_value);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: const JSONNode& JSONNode::get(const String& child_node) const
 
        returns the child, if it exists. Is read only. Same as (*this)[child_node]
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        child_node - The name of the node you want to return. Must be an existing child node.
        *-----------------------------------------------------------------------------------------------**/
        const JSONNode& get(const String& child_node) const
        {
            return *m_json_children[child_node];
        }
        /**--------------------------------------------------------------------------------------------------
        Fn: const JSONNode& JSONNode::operator[](const String& child_node) const
 
        returns the child, if it exists. Is read only. Same as get
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        child_node - The name of the node you want to return. Must be an existing child node.
        *-----------------------------------------------------------------------------------------------**/
        const JSONNode& operator[](const String& child_node) const;
        JSONNode& operator[](const String& child_node);
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONNode& JSONNode::operator[](const uint04& child_node)
 
        Returns the child, if it exists.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Parameters:
        child_idx - The index of the node you want to return.
        *-----------------------------------------------------------------------------------------------**/
        JSONNode& operator[](const uint04& child_idx);
        const JSONNode& operator[](const uint04& child_idx) const;
 
        const Buffer<JSONNode*>& children() const
        {
            return m_sorted_json_children;
        }
        bool hasNode(const String& child_node) const
        {
            return m_json_children.hasKey(child_node);
        }
 
        const String& nodeName() const
        {
            return m_name;
        }
 
        void remove(const String& child_node);
        JSONNode& createChildNode(const String& child_node, NodeType type);
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::operator=(const JSONNode& node)
 
        A special case of the = operator for nodes. Note that this will not set the name of the node, but
        set the contents equal to that of another
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        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 auto& 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)
            {
                m_sorted_json_children.add(new JSONNode(*iter));
                if (!m_json_children.hasKey(iter->nodeName()))
                    m_json_children.add(iter->nodeName(), m_sorted_json_children.last());
            }
            return *this;
        }
 
 
        JSONNode& operator=(const String& 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 = String(value.template as<DEGREES>());
            return *this;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::operator=(const Time& node)
 
        A special case Time equals. writes in YYYY/MM/DDTHH:mm:ss.fffZ format.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        JSONNode& operator=(const Time& time)
        {
            m_type = e_object;
            m_value = time.toString(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 = String(buffer);
            return *this;
        }
 
        template<uint01 t_dims, class t_type>
        JSONNode& operator=(const Vector<t_dims, t_type>& buffer)
        {
            m_type = e_array;
            m_value = String(buffer);
            return *this;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: bool JSONNode::isEmpty() const
 
        Returns true if the node contains no information.
 
        Author: Tyler Parke
 
        Date: 2019-14-12
        *-----------------------------------------------------------------------------------------------**/
        [[nodiscard]] bool isEmpty() const
        {
            return m_value.size() == 0 && m_json_children.size() == 0;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::operator=(const t_type& node)
 
        A general case t_type equals. Sets the value internal and predicts the type.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        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 = String(value);
            return *this;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void JSONNode::operator=()
 
        Returns the number of children within this node.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        uint04 size()
        {
            return cast<uint04>(m_json_children.size());
        }
        //Used for parsing our children in a for/each loop
        [[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:
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONParser::parseJSON(Scanner& scan)
 
        Reads in the next JSON item and adds it to this node's children
 
        Parameters:
        scan -  The object tasked with reading in our data. Shold be just past the second '"' at the end of
        the node's title at this point.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Returns: true if there is an adjacent child next to this one, false if end of stream or no additional
        children.
        *-----------------------------------------------------------------------------------------------**/
        bool parseJSON(Scanner& scan);
        bool parseJSONContent(char start, Scanner& scan);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONParser::parseYAML(Scanner& scan)
 
        Reads in the next YAML item and adds it to this node's children
 
        Parameters:
        scan -  The object tasked with reading in our data. Shold be just past the second '"' at the end of
        the node's title at this point.
 
        Author: Tyler Parke
 
        Date: 2024-07-08
 
        Returns: true if there is an adjacent child next to this one, false if end of stream or no additional
        children.
        *-----------------------------------------------------------------------------------------------**/
        bool parseYAMLContent(uint04 indentention, Scanner& scan);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONParser::readChildrenNodes(Scanner& scan)
 
        Reads in all of the children nodes for this node and adds them to the children list
 
        Parameters:
        scan -  The object tasked with reading in our data. Shold be just before the first '"' specifying
        the title
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        void readChildrenNodes(Scanner& scan);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONParser::readData(Scanner& scan)
 
        Reads in a single object type for this child.
 
        Parameters:
        scan -  The object tasked with reading in our data. Shold be just past the first '"' specifying
        the data
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        void readData(Scanner& scan);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONParser::readArray(Scanner& scan)
 
        Reads in an array of items for this child.
 
        Parameters:
        scan -  The object tasked with reading in our data. Shold be just past the first '[' specifying
        the beginning of the array
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        void readArray(Scanner& scan);
 
        /**--------------------------------------------------------------------------------------------------
        Fn: JSONParser::WriteTabs(String& stream, uint04 tab_indention)
 
        Writes tabs to the file
 
        Parameters:
        stream - Where to append the tabs
        tab_indention - The number of tabs to write
 
        Author: Tyler Parke
 
        Date: 2017-11-19
        *-----------------------------------------------------------------------------------------------**/
        static void WriteTabs(String& stream, uint04 tab_indention);
        static void ConvertToJSONString(String& string);
        static void ConvertFromJSONString(String& string);
    protected:
        static TranslatedString UnexpectedCharErrorString(char current_char, const Scanner& scan);
        static TranslatedString DuplicateChildErrorString(const String& child, const Scanner& scan);
        static TranslatedString BadChildErrorString(const Scanner& scan);
    protected:
        Buffer<JSONNode*> m_sorted_json_children;
        Dictionary<String, JSONNode*> m_json_children;//The children of this node. If the node type is not e_node or e_root, this is empty
        const String m_name;  //The name of the node
        String m_value; //The value of the node
        NodeType m_type;// the type of the node.
    };
 
}