Json.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2022–2023 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program 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 in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * Json.hpp
 *
 * Namespace for global JSON helper functions.
 *
 *  Created on: Jan 9, 2019
 *      Author: ans
 */

#ifndef HELPER_JSON_HPP_
#define HELPER_JSON_HPP_

#include "Strings.hpp"

#include "../Main/Exception.hpp"
#include "../Struct/TextMap.hpp"

#include "../_extern/jsoncons/include/jsoncons/json.hpp"

#include <cstddef>  // std::size_t

namespace rapidjson { typedef ::std::size_t SizeType; }

#include "../_extern/rapidjson/include/rapidjson/document.h"
#include "../_extern/rapidjson/include/rapidjson/error/en.h"
#include "../_extern/rapidjson/include/rapidjson/error/error.h"
#include "../_extern/rapidjson/include/rapidjson/stringbuffer.h"
#include "../_extern/rapidjson/include/rapidjson/writer.h"

#include <cctype>   // std::iscntrl, std::isxdigit, std::tolower
#include <string>   // std::string
#include <utility>  // std::pair
#include <vector>   // std::vector

namespace crawlservpp::Helper::Json {

    /*
     * CONSTANTS
     */


    inline constexpr auto unicodeEscapeLength{6};

    inline constexpr auto unicodeEscapeDigit1{2};

    inline constexpr auto unicodeEscapeDigit2{3};

    inline constexpr auto unicodeEscapeDigit3{4};

    inline constexpr auto unicodeEscapeDigit4{5};

    inline constexpr auto numDebugChars{25};


    /*
     * DECLARATION
     */


    [[nodiscard]] std::string stringify(const std::vector<std::string>& vectorToStringify);
    [[nodiscard]] std::string stringify(const std::string& stringToStringify);
    [[nodiscard]] std::string stringify(const char * stringToStringify);
    [[nodiscard]] std::string stringify(
            const std::vector<std::vector<std::pair<std::string, std::string>>>& vectorToStringify
    );
    [[nodiscard]] std::string stringify(const Struct::TextMap& textMapToStringify);
    [[nodiscard]] std::string stringify(const rapidjson::Value& value);
    [[nodiscard]] std::string stringify(const jsoncons::json& json);


    [[nodiscard]] std::string cleanCopy(std::string_view json);
    [[nodiscard]] rapidjson::Document parseRapid(std::string_view json);
    [[nodiscard]] jsoncons::json parseCons(std::string_view json);
    [[nodiscard]] Struct::TextMap parseTextMapJson(std::string_view json);
    [[nodiscard]] std::vector<std::pair<std::size_t, std::size_t>> parsePosLenPairsJson(
            std::string_view json
    );


    static void free(rapidjson::Document& target);


    /*
     * CLASS FOR JSON EXCEPTIONS
     */


    MAIN_EXCEPTION_CLASS();

    /*
     * IMPLEMENTATION
     */


    inline std::string stringify(const std::vector<std::string>& vectorToStringify) {
        // create document as array and get reference to allocator
        rapidjson::Document document;
        
        document.SetArray();
        
        rapidjson::Document::AllocatorType& allocator{document.GetAllocator()};

        // reserve memory for all array elements
        document.Reserve(vectorToStringify.size(), allocator);

        // write vector elements as string values to array
        for(const auto& element : vectorToStringify) {
            rapidjson::Value stringValue;
            
            stringValue.SetString(element, allocator);
            
            document.PushBack(stringValue, allocator);
        }

        // create string buffer and writer
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

        // write array to string buffer
        document.Accept(writer);

        // return string
        return std::string(buffer.GetString(), buffer.GetSize());
    }


    inline std::string stringify(const std::string& stringToStringify) {
        // create document as array and get reference to allocator
        rapidjson::Document document;
        
        document.SetArray();
        
        rapidjson::Document::AllocatorType& allocator{document.GetAllocator()};

        // write string as string element to array
        rapidjson::Value stringValue;
        
        stringValue.SetString(stringToStringify, allocator);
        
        document.PushBack(stringValue, allocator);

        // create string buffer and writer
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

        // write array to string buffer
        document.Accept(writer);

        // return string
        return std::string(buffer.GetString(), buffer.GetSize());
    }


    inline std::string stringify(const char * stringToStringify) {
        return stringify(std::string(stringToStringify));
    }


    inline std::string stringify(const std::vector<std::vector<std::pair<std::string, std::string>>>& vectorToStringify) {
        // create document as array and get reference to allocator
        rapidjson::Document document;
        
        document.SetArray();
        
        rapidjson::Document::AllocatorType& allocator{document.GetAllocator()};

        // reserve memory for all array elements
        document.Reserve(vectorToStringify.size(), allocator);

        // go through the vector elements representing the objects in the array
        for(const auto& element : vectorToStringify) {
            // create object and reserve memory for all [key, value] pairs
            rapidjson::Value objectValue;
            
            objectValue.SetObject();

            // go through the sub-vector elements representing the [key, value] pairs in the object
            for(const auto& pair : element) {
                // create key
                rapidjson::Value key;
                
                key.SetString(pair.first, allocator);

                // create value
                rapidjson::Value value;
                
                value.SetString(pair.second, allocator);

                // add [key, value] pair to object
                objectValue.AddMember(key, value, allocator);
            }

            // add object to array
            document.PushBack(objectValue, allocator);
        }

        // create string buffer and writer
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

        // write array to string buffer
        document.Accept(writer);

        // return string
        return std::string(buffer.GetString(), buffer.GetSize());
    }


    inline std::string stringify(const Struct::TextMap& textMapToStringify) {
        // create document as array and get refference to allocator
        rapidjson::Document document;
        
        document.SetArray();
        
        rapidjson::Document::AllocatorType& allocator{document.GetAllocator()};

        // reserve memory for all array elements
        document.Reserve(textMapToStringify.size(), allocator);

        // go through the vector elements representing the objects in the array
        for(const auto& textMapEntry : textMapToStringify) {
            // create object and reserve memory for all [key, value] pairs
            rapidjson::Value objectValue;
            
            objectValue.SetObject();

            // create and add [key, value] pair for position
            rapidjson::Value keyPos;
            
            keyPos.SetString("p", 1, allocator);
            
            rapidjson::Value valuePos;
            
            valuePos.SetUint64(Struct::TextMapEntry::pos(textMapEntry));
            
            objectValue.AddMember(keyPos, valuePos, allocator);

            // create and add [key, value] pair for length
            rapidjson::Value keyLength;
            
            keyLength.SetString("l", 1, allocator);
            
            rapidjson::Value valueLength;
            
            valueLength.SetUint64(Struct::TextMapEntry::length(textMapEntry));
            
            objectValue.AddMember(keyLength, valueLength, allocator);

            // create and add [key, value] pair for describing string
            rapidjson::Value keyValue;

            keyValue.SetString("v", 1, allocator);

            rapidjson::Value valueValue;

            valueValue.SetString(textMapEntry.value, allocator);

            objectValue.AddMember(keyValue, valueValue, allocator);

            // add object to array
            document.PushBack(objectValue, allocator);
        }

        // create string buffer and writer
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

        // write array to string buffer
        document.Accept(writer);

        // return string
        return std::string(buffer.GetString(), buffer.GetSize());
    }


    inline std::string stringify(const rapidjson::Value& value) {
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

        value.Accept(writer);

        return std::string(buffer.GetString(), buffer.GetSize());
    }


    inline std::string stringify(const jsoncons::json& json) {
        std::string result;

        json.dump(result);

        return result;
    }


    inline std::string cleanCopy(std::string_view json) {
        if(json.empty()) {
            return std::string();
        }

        std::string result;

        for(std::size_t n{}; n < json.length(); ++n) {
            // ignore control characters
            if(std::iscntrl(json[n]) != 0) {
                continue;
            }

            // check escape sequences
            if(json[n] == '\\') {
                bool validEscapeSequence{false};

                if(n < json.length() - 1) {
                    switch(std::tolower(json[n + 1])) {
                    // check for escaped backslash
                    case '\\':
                        // do not check the following (escaped) backslash...
                        ++n;

                        // ...but add the ignored backslash to the result
                        result.push_back('\\');

                        validEscapeSequence = true;

                        break;

                    // check for single-digit escape sequence names
                    case 'b':
                    case 'f':
                    case 'n':
                    case 'r':
                    case 't':
                    case '\"':
                    case '\'': /* non-standard lenience */
                    case '/':
                        validEscapeSequence = true;

                        break;

                    // check for escaped Unicode character sequence
                    case 'u':
                        if(n < json.length() - unicodeEscapeLength) {
                            validEscapeSequence =
                                    ::isxdigit(json[n + unicodeEscapeDigit1]) != 0
                                    && ::isxdigit(json[n + unicodeEscapeDigit2]) != 0
                                    && ::isxdigit(json[n + unicodeEscapeDigit3]) != 0
                                    && ::isxdigit(json[n + unicodeEscapeDigit4]) != 0;
                        }

                        break;

                    default:
                        break;
                    }
                }

                if(!validEscapeSequence) {
                    // simply escape the backslash of an invalid escape sequence
                    result.push_back('\\');
                }

                result.push_back('\\');
            }
            else {
                result.push_back(json[n]);
            }
        }

        return result;
    }


    inline rapidjson::Document parseRapid(std::string_view json) {
        // clean input
        std::string cleanJson(cleanCopy(json));

        rapidjson::Document doc;

        doc.Parse(cleanJson);

        if(doc.HasParseError() && cleanJson.find('\\') != std::string::npos) {
            // try again with escaped backslashes
            Strings::replaceAll(cleanJson, "\\", "\\\\");

            doc.Parse(cleanJson);
        }

        if(doc.HasParseError()) {
            std::string exceptionStr{
                "Json::parseRapid(): "
            };

            exceptionStr += rapidjson::GetParseError_En(doc.GetParseError());
            exceptionStr += " at '";

            if(doc.GetErrorOffset() > numDebugChars) {
                exceptionStr += cleanJson.substr(doc.GetErrorOffset() - numDebugChars, numDebugChars);
            }
            else if(doc.GetErrorOffset() > 0) {
                exceptionStr += cleanJson.substr(0, doc.GetErrorOffset());
            }

            exceptionStr += "[!]";

            if(cleanJson.size() > doc.GetErrorOffset() + numDebugChars) {
                exceptionStr += cleanJson.substr(doc.GetErrorOffset(), numDebugChars);
            }
            else if(cleanJson.size() > doc.GetErrorOffset()) {
                exceptionStr += cleanJson.substr(doc.GetErrorOffset());
            }

            exceptionStr += "'";

            throw Exception(exceptionStr);
        }

        return doc;
    }


    inline jsoncons::json parseCons(std::string_view json) {
        // clean input
        std::string cleanJson(cleanCopy(json));

        try {
            jsoncons::json result{jsoncons::json::parse(cleanJson)};

            return result;
        }
        catch(const jsoncons::json_exception&) {
            try {
                if(cleanJson.find('\\') == std::string::npos) {
                    throw;
                }

                // try again with replaced backslashes
                Strings::replaceAll(cleanJson, "\\", "\\\\");

                jsoncons::json result{jsoncons::json::parse(cleanJson)};

                return result;
            }
            catch(const jsoncons::json_exception& e2) {
                throw Exception(
                        "Json::parseCons(): "
                        + std::string(e2.what())
                );
            }
        }
    }


    inline Struct::TextMap parseTextMapJson(std::string_view json) {
        if(json.empty()) {
            return {};
        }

        // parse JSON
        rapidjson::Document document{parseRapid(json)};

        if(!document.IsArray()) {
            throw Exception(
                    "Json::parseTextMapJson():"
                    " Invalid text map"
                    " (is not an array)"
            );
        }

        Struct::TextMap result;

        for(const auto& element : document.GetArray()) {
            if(!element.IsObject()) {
                throw Exception(
                        "Json::parseTextMapJson():"
                        " Invalid text map"
                        " (an array element is not an object"
                );
            }

            const auto p{element.FindMember("p")};
            const auto l{element.FindMember("l")};
            const auto v{element.FindMember("v")};

            if(p == element.MemberEnd() || !(p->value.IsUint64())) {
                throw Exception(
                        "Json::parseTextMapJson():"
                        " Invalid text map"
                        " (could not find valid position)"
                );
            }

            if(l == element.MemberEnd() || !(l->value.IsUint64())) {
                throw Exception(
                        "Json::parseTextMapJson():"
                        " Invalid text map"
                        " (could not find valid length)"
                );
            }

            if(v == element.MemberEnd() || !(v->value.IsString())) {
                throw Exception(
                        "Json::parseTextMapJson():"
                        " Invalid text map"
                        " (could not find valid value)"
                );
            }

            result.emplace_back(
                    p->value.GetUint64(),
                    l->value.GetUint64(),
                    std::string(
                            v->value.GetString(),
                            v->value.GetStringLength()
                    )
            );
        }

        return result;
    }


    inline std::vector<std::pair<std::size_t, std::size_t>> parsePosLenPairsJson(
            std::string_view json
    ) {
        if(json.empty()) {
            return {};
        }

        // parse JSON
        rapidjson::Document document{parseRapid(json)};

        if(!document.IsArray()) {
            throw Exception(
                    "Json::parsePosLenPairsJson():"
                    " Invalid array of [pos;length] pairs"
                    " (is not an array)"
            );
        }

        std::vector<std::pair<std::size_t, std::size_t>> result;

        for(const auto& element : document.GetArray()) {
            if(!element.IsArray()) {
                throw Exception(
                        "Json::parsePosLenPairsJson():"
                        " Invalid array of [pos;length] pairs"
                        " (an array element is not an array)"
                );
            }

            if(element.Size() != 2) {
                throw Exception(
                        "Json::parsePosLenPairsJson():"
                        " Invalid array of [pos;length] pairs"
                        " (a pair is not of size 2)"
                );
            }

            const auto a{element.GetArray()};

            if(!(a[0].IsUint64())) {
                throw Exception(
                        "Json::parsePosLenPairsJson():"
                        " Invalid array of [pos;length] pairs"
                        " (could not find valid position)"
                );
            }

            if(!(a[1].IsUint64())) {
                throw Exception(
                        "Json::parsePosLenPairsJson():"
                        " Invalid array of [pos;length] pairs"
                        " (could not find valid length)"
                );
            }

            result.emplace_back(
                    a[0].GetUint64(),
                    a[1].GetUint64()
            );
        }

        return result;
    }


    inline void free(rapidjson::Document& target) {
        rapidjson::Value(rapidjson::kObjectType).Swap(target);
    }

} /* namespace crawlservpp::Helper::Json */

#endif /* HELPER_JSON_HPP_ */