JsonPath.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2020 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/>.
 *
 * ---
 *
 * JSONPath.hpp
 *
 * Using the jsoncons library to implement a JSONPath query
 *  with boolean, single and/or multiple results.
 *
 *  Created on: Apr 26, 2019
 *      Author: ans
 */

#ifndef QUERY_JSONPATH_HPP_
#define QUERY_JSONPATH_HPP_

#include "../Helper/Strings.hpp"
#include "../Main/Exception.hpp"

#include "../_extern/jsoncons/include/jsoncons/json.hpp"
#include "../_extern/jsoncons/include/jsoncons_ext/jsonpath/json_query.hpp"

#include <string>   // std::string
#include <vector>   // std::vector

namespace crawlservpp::Query {

    /*
     * DECLARATION
     */


    class JsonPath {
    public:

        JsonPath(const std::string& pathString, bool textOnlyQuery);


        [[nodiscard]] bool getBool(const jsoncons::json& json) const;
        void getFirst(const jsoncons::json& json, std::string& resultTo) const;
        void getAll(const jsoncons::json& json, std::vector<std::string>& resultTo) const;
        void getSubSets(const jsoncons::json& json, std::vector<jsoncons::json>& resultTo) const;



        MAIN_EXCEPTION_CLASS();

    private:
        std::string jsonPath;
        const bool textOnly;
    };

    /*
     * IMPLEMENTATION
     */


    inline JsonPath::JsonPath(const std::string& pathString, bool textOnlyQuery)
            : jsonPath(pathString),
              textOnly(textOnlyQuery) {
        Helper::Strings::trim(this->jsonPath);

        if(this->jsonPath.empty()) {
            throw Exception("No JSONPath string given");
        }
    }


    inline bool JsonPath::getBool(const jsoncons::json& json) const {
        // check JSONPath query
        if(this->jsonPath.empty()) {
            throw Exception("No JSONPath query defined");
        }

        try {
            // evaluate query with boolean result
            const auto result{jsoncons::jsonpath::json_query(json, this->jsonPath)};

            return !(result.is_array() && result.empty());
        }
        catch(const jsoncons::json_exception& e) {
            throw Exception(
                    std::string(e.what())
                    + " (JSONPath: '"
                    + this->jsonPath
                    + "')"
            );
        }
    }


    inline void JsonPath::getFirst(const jsoncons::json& json, std::string& resultTo) const {
        // empty target
        resultTo.clear();

        // check JSONPath
        if(this->jsonPath.empty()) {
            throw Exception("No JSONPath defined");
        }

        try {
            // get result
            const auto result{jsoncons::jsonpath::json_query(json, this->jsonPath)};

            // check validity of result
            if(!result.is_array()) {
                throw Exception("jsoncons::jsonpath::json_query() did not return an array");
            }

            // check whether there are matches
            if(!result.array_value().empty()) {
                if(result[0].is_array() && !(this->textOnly)) {
                    // return first array member of first match
                    resultTo = result[0][0].as<std::string>();
                }
                else {
                    // return first match only
                    resultTo = result[0].as<std::string>();
                }
            }
        }
        catch(const jsoncons::json_exception& e) {
            throw Exception(
                    std::string(e.what())
                    + " (JSONPath: '"
                    + this->jsonPath + "')"
            );
        }
    }


    inline void JsonPath::getAll(const jsoncons::json& json, std::vector<std::string>& resultTo) const {
        // empty target
        resultTo.clear();

        // check JSONPath
        if(this->jsonPath.empty()) {
            throw Exception("No JSONPath defined");
        }

        try {
            // get result
            const auto result{jsoncons::jsonpath::json_query(json, this->jsonPath)};

            // check validity of result
            if(!result.is_array()) {
                throw Exception("jsoncons::jsonpath::json_query() did not return an array");
            }

            // check number of matches
            switch(result.array_value().size()) {
            case 0:
                break;

            case 1:
                if(result[0].is_array() && !(this->textOnly)) {
                    // return all array members of first match
                    resultTo.reserve(result[0].array_value().size());

                    for(const auto& element : result[0].array_range()) {
                        resultTo.emplace_back(element.as<std::string>());
                    }
                }
                else {
                    resultTo.emplace_back(result[0].as<std::string>());
                }

                break;

            default:
                // return all matches
                resultTo.reserve(result.array_value().size());

                for(const auto& element : result.array_range()) {
                    resultTo.emplace_back(element.as<std::string>());
                }
            }
        }
        catch(const jsoncons::json_exception& e) {
            throw Exception(
                    std::string(e.what())
                    + " (JSONPath: '"
                    + this->jsonPath + "')"
            );
        }
    }


    inline void JsonPath::getSubSets(const jsoncons::json& json, std::vector<jsoncons::json>& resultTo) const {
        // empty target
        resultTo.clear();

        // check JSONPath
        if(this->jsonPath.empty()) {
            throw Exception("No JSONPath defined");
        }

        try {
            // get result
            const auto result{jsoncons::jsonpath::json_query(json, this->jsonPath)};

            // check validity of result
            if(!result.is_array()) {
                throw Exception("jsoncons::jsonpath::json_query() did not return an array");
            }

            // check number of matches
            switch(result.array_value().size()) {
            case 0:
                break;

            case 1:
                if(result[0].is_array() && !(this->textOnly)) {
                    // return all array members of first match
                    resultTo.reserve(result[0].array_value().size());

                    for(const auto& element : result[0].array_range()) {
                        resultTo.emplace_back(element);
                    }
                }
                else {
                    resultTo.emplace_back(result[0]);
                }

                break;

            default:
                // return all matches
                resultTo.reserve(result.array_value().size());

                for(const auto& element : result.array_range()) {
                    resultTo.emplace_back(element);
                }
            }
        }
        catch(const jsoncons::json_exception& e) {
            throw Exception(
                    std::string(e.what())
                    + " (JSONPath: '"
                    + this->jsonPath + "')"
            );
        }
    }

} /* namespace crawlservpp::Query */

#endif /* QUERY_JSONPATH_HPP_ */