json.hpp

Go to the documentation of this file.

#ifndef _json_json_hpp_
#define _json_json_hpp_

/*
 * Copyright (c) 2017 Andrew Haisley
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * 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.
 */


#include <memory>
#include <map>
#include <vector>

#include "common.hpp"
#include "pointer.hpp"

namespace NAMESPACE
{
    class json
    {
    public:

        // Convenience definition for creating null instances
        typedef decltype(nullptr) null_t;

        typedef enum 
        { 
            object_e, 
            array_e, 
            boolean_e, 
            null_e, 
            number_int_e, 
            number_double_e, 
            string_e 
        } 
        type;

        json() noexcept;

        ~json();

        json(const json &other);

        json(json &&other) noexcept;

        json(type t);

        json(type t, const std::string &raw_value);

        json(int i);

        json(double d);

        json(bool b);

        json(const std::string &s);

        json(const char *s);

        json(null_t) noexcept;

        json(std::unique_ptr<std::string> s);

        json &operator=(const json &other);

        json &operator=(json &&other) noexcept;

        json &operator=(int i);

        json &operator=(double d);

        json &operator=(bool b);

        json &operator=(const char *s);

        json &operator=(const std::string &s);

        json &operator=(std::unique_ptr<std::string> s);

        json &operator=(const std::map<std::string, std::unique_ptr<json>> &o);

        json &operator=(const std::vector<std::unique_ptr<json>> &a);

        json &operator=(null_t);

        type get_instance_type() const;

        const char *get_instance_type_name() const;

        std::vector<std::unique_ptr<json>> &get_array();

        const std::vector<std::unique_ptr<json>> &get_array() const;

        std::map<std::string, std::unique_ptr<json>> &get_object();

        const std::map<std::string, std::unique_ptr<json>> &get_object() const;

        operator int() const;

        operator double() const;

        operator const std::string&() const;

        operator bool() const;

        json &operator[](const std::string &name);

        json &operator[](const char *name);

        const json &operator[](const std::string &name) const;

        const json &operator[](const char *name) const;

        json &operator[](size_t index);

        json &operator[](int index);

        const json &operator[](size_t index) const;

        const json &operator[](int index) const;

        const json &append(const json &j);

        const json &append(std::unique_ptr<json> j);

        const json &insert(const std::string &name, const json &j);

        const json &insert(const std::string &name, std::unique_ptr<json> j);

        const std::string &get_raw_value() const;

        bool operator==(const json &other) const;

        bool operator!=(const json &other) const;

        bool operator<(const json &other) const;

        bool operator<=(const json &other) const;

        bool operator>(const json &other) const;

        bool operator>=(const json &other) const;

        bool operator==(int i) const;
        bool operator==(double d) const;
        bool operator==(const std::string &s) const;
        bool operator==(const char *s) const;
        bool operator!=(int i) const;
        bool operator!=(double d) const;
        bool operator!=(const std::string &s) const;
        bool operator!=(const char *s) const;
        bool operator<(int i) const;
        bool operator<(double d) const;
        bool operator<(const std::string &s) const;
        bool operator<(const char *s) const;
        bool operator<=(int i) const;
        bool operator<=(double d) const;
        bool operator<=(const std::string &s) const;
        bool operator<=(const char *s) const;
        bool operator>(int i) const;
        bool operator>(double d) const;
        bool operator>(const std::string &s) const;
        bool operator>(const char *s) const;
        bool operator>=(int i) const;
        bool operator>=(double d) const;
        bool operator>=(const std::string &s) const;
        bool operator>=(const char *s) const;

        const json &find(const pointer &p) const;

    private:

        typedef union
        {
            std::map<std::string, std::unique_ptr<json>> *u_object;
            std::vector<std::unique_ptr<json>> *u_array;
            bool u_boolean;
            int u_number_int;
            double u_number_double;
            std::string *u_string;
        }
        json_value;

        type m_type;

        json_value m_value;

        std::string m_raw_value;

        void reset();

        void copy_json(const json &other);

        void move_json(json &other);

        bool number_equal(const json &other) const;

        bool string_equal(const json &other) const;

        bool object_equal(const json &other) const;

        bool array_equal(const json &other) const;

    };
}

#endif