jsonLoader.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 JSONLOADER_H_INCLUDED
#define JSONLOADER_H_INCLUDED

#include "jsonObject.h"
#include <fstream>
#include <optional>

namespace JSON {

void JSONAssert(bool               condition,
                std::string const& spec);

class Reader {

    public:

    Reader() = delete;

    public:

    static std::unique_ptr<Node> loadFromFile(std::string const& nameFile);

    static void saveToFile(std::string const& nameFile,
                           Node*              tree);

    static void saveToFile(std::string           const& nameFile,
                           std::unique_ptr<Node> const& tree);

    private:

    static int readLineNumber();

    static void readingError(std::string const& error);

    static void unexpectedEndOfFile();

    static char readSeparator();

    static std::string readString();

    static char readBoolean(char         first,
                            std::string& strBool);

    static char readNumber(char         first,
                           std::string& strNumber);

    static char getBooleanLeaf(Child&             child,
                               std::string const& specifier,
                               char               first);

    static char getNumberLeaf(Child&             child,
                              std::string const& specifier,
                              char               first);

    static char getStringLeaf(Child&             child,
                              std::string const& specifier);

    static char readNode(Child&             child,
                         std::string const& specifier);

    static char readList(Child&             child,
                         std::string const& specifier);

    static char readObject(Child&             child,
                           std::string const& specifier);

    static char readObject(Child&             child,
                           std::string const& specifier,
                           char               first);

    static void writeToFileWithIndent(std::string const& str);

    static void writeToFile(Object* object,
                            bool    writeSpec = true);

    private:

    inline static std::ofstream       fout;

    inline static std::ifstream       fin;

    inline static std::string         currentFileName;

    constexpr static const int indentStep = 2;

    inline static int                 indent;
};

class Parser {

    public:

    Parser() = delete;

    public:

    template<typename Targ>
        static std::optional<Targ> parseArgument(
                Node*              node,
                std::string const& specifier,
                bool               mandatory = false) {
            if (not node)
                return std::nullopt;
            for (const auto& object : *node) {
                if (object->getSpecifier() == specifier) {
                    return interpretObject<Targ>(object.get());
                }
            }
            JSONAssert(not mandatory,
                    "Argument \"" + specifier + "\" should be specified in "
                    + "node \"" + node->getSpecifier() + "\".");
            return std::nullopt;
        }

    template<typename Targ>
        static std::optional<Targ> parseArgument(
                std::unique_ptr<Object> const& object,
                std::string             const& specifier,
                bool                           mandatory = false) {
            return parseArgument<Targ>(convert(object), specifier, mandatory);
        }

    static Node* parseNode(Node*              parent,
                           std::string const& specifier,
                           bool               mandatory = false); 

    static Node* parseNode(std::unique_ptr<Object> const& parent,
                           std::string             const& specifier,
                           bool                           mandatory = false); 

    template<typename Targ>
        static Targ interpretObject(Object* object) {
            JSONAssert(typeid(*object) == typeid(Leaf<Targ>),
                    "Bad type required in JSON::interpretObject for object \""
                  + object->getSpecifier() + "\": \""
                  + (std::string)(typeid(*object).name()) + "\" given, \""
                  + (std::string)(typeid(Leaf<Targ>).name()) + "\" expected.");
            return static_cast<Leaf<Targ>*>(object)->getTypedArgument();
        }

    static Node* convert(const std::unique_ptr<Object>& node); 
};

} // End of namespace JSON


#endif