jsonObject.h

// This file is part of MARTY.
// 
// MARTY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// MARTY is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef JSONOBJECT_H_INCLUDED
#define JSONOBJECT_H_INCLUDED

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <memory>
#include <cmath>

namespace JSON {

class Object {

    public:

    explicit
    Object(std::string const& t_specifier): specifier(t_specifier) {}

    virtual ~Object() {};

    std::string getSpecifier() const {
        return specifier;
    }

    virtual bool isNode() const {
        return false;
    }

    protected:

    std::string specifier;
};

typedef std::unique_ptr<Object> Child;

class Node: public Object {

    public:

    explicit
    Node(std::string const& specifier): Object(specifier) {}

    static
    std::unique_ptr<Node> make(std::string const& specifier) {
        return std::make_unique<Node>(specifier);
    }

    bool isNode() const override {
        return true;
    }

    virtual void addChild(Child& child) {
        children.push_back(std::move(child));
    }

    template<class T>
    inline void addChild(std::unique_ptr<T>& child) {
        Child c = std::move(child);
        addChild(c);
    }

    virtual void addChild(Child&& child) {
        children.push_back(std::move(child));
    }

    template<class T>
    inline void addChild(std::unique_ptr<T>&& child) {
        Child c = std::move(child);
        addChild(c);
    }
    
    size_t size() const {
        return children.size();
    }

    bool empty() const {
        return children.empty();
    }

    std::vector<Child>::const_iterator begin() const {
        return children.begin();
    }

    std::vector<Child>::const_iterator end() const {
        return children.end();
    }

    std::vector<Child>::iterator begin() {
        return children.begin();
    }

    std::vector<Child>::iterator end() {
        return children.end();
    }

    Object* getChild(std::string const& spec) const {
        for (const auto& child : children)
            if (child->getSpecifier() == spec)
                return child.get();
        return nullptr;
    }
    
    private:

    std::vector<Child> children;
};

class List: public Node {

    public:

    explicit
    List(std::string const& specifier): Node(specifier) {}

    static
    std::unique_ptr<List> make(std::string const& specifier) {
        return std::make_unique<List>(specifier);
    }

    void addChild(Child& child) override {
        if (child->getSpecifier() != specifier) {
            std::cerr << "JSONParsingError: difference specification"
                << " \"" << child->getSpecifier() << "\" in list.\n";
            exit(1);
        }
        Node::addChild(child);
    }

    template<class T>
    void addChild(std::unique_ptr<T>& child) {
        if (child->getSpecifier() != specifier) {
            std::cerr << "JSONParsingError: difference specification"
                << " \"" << child->getSpecifier() << "\" in list.\n";
            exit(1);
        }
        Node::addChild(child);
    }

    void addChild(Child&& child) override {
        if (child->getSpecifier() != specifier) {
            std::cerr << "JSONParsingError: difference specification"
                << " \"" << child->getSpecifier() << "\" in list.\n";
            exit(1);
        }
        Node::addChild(std::move(child));
    }

    template<class T>
    void addChild(std::unique_ptr<T>&& child) {
        if (child->getSpecifier() != specifier) {
            std::cerr << "JSONParsingError: difference specification"
                << " \"" << child->getSpecifier() << "\" in list.\n";
            exit(1);
        }
        Node::addChild(std::move(child));
    }
};

class AbstractLeaf: public Object {
    public:

    explicit
    AbstractLeaf(std::string const& specifier): Object(specifier) {}

    virtual std::string getArgument() const = 0;
};

template<typename Type>
class Leaf: public AbstractLeaf {

    public:

    Leaf(std::string const& specifier, Type t_argument)
        :AbstractLeaf(specifier), argument(t_argument) {}

    static
    Child make(std::string const& specifier, Type t_argument) {
        return std::make_unique<Leaf<Type>>(specifier, t_argument);
    }

    std::string getArgument() const {
        std::ostringstream sout;
        if (typeid(argument) == typeid(std::string)) 
            sout << "\"" << argument << "\"";
        else
            sout << argument;
        if constexpr(std::is_same<Type, double>::value) {
            if (argument == std::round(argument)) {
                sout << '.' << '0';
            }
        }

        return sout.str();
    }

    Type getTypedArgument() const {
        return argument;
    }

    private:

    mutable Type argument;
};

} // End of namespace JSON

#endif