json11::Json Class Reference

#include <json11.hpp>

Collaboration diagram for json11::Json:

Public Types
enum	Type {   NUL, NUMBER, BOOL, STRING,   ARRAY, OBJECT }
typedef std::vector< Json >	array
typedef std::map< std::string, Json >	object
typedef std::initializer_list< std::pair< std::string, Type > >	shape

Public Member Functions
	Json () noexcept
	Json (std::nullptr_t) noexcept
	Json (double value)
	Json (int value)
	Json (bool value)
	Json (const std::string &value)
	Json (std::string &&value)
	Json (const char *value)
	Json (const array &values)
	Json (array &&values)
	Json (const object &values)
	Json (object &&values)
template<class T , class = decltype(&T::to_json)>
	Json (const T &t)
template<class M , typename std::enable_if< std::is_constructible< std::string, decltype(std::declval< M >().begin() ->first)>::value &&std::is_constructible< Json, decltype(std::declval< M >().begin() -> second>
	Json (const M &m)
template<class V , typename std::enable_if< std::is_constructible< Json, decltype(*std::declval< V >().begin())>::value, int >::type = 0>
	Json (const V &v)
	Json (void *)=delete
Type	type () const
std::string	type_name () const
bool	is_null () const
bool	is_number () const
bool	is_bool () const
bool	is_string () const
bool	is_array () const
bool	is_object () const
double	number_value () const
int	int_value () const
bool	bool_value () const
const std::string &	string_value () const
const array &	array_items () const
const object &	object_items () const
const Json &	operator[] (size_t i) const
const Json &	operator[] (const std::string &key) const
void	dump (std::string &out) const
std::string	dump () const
bool	operator== (const Json &rhs) const
bool	operator< (const Json &rhs) const
bool	operator!= (const Json &rhs) const
bool	operator<= (const Json &rhs) const
bool	operator> (const Json &rhs) const
bool	operator>= (const Json &rhs) const
bool	has_shape (const shape &types, std::string &err) const

Static Public Member Functions
static Json	parse (const std::string &in, std::string &err, JsonParse strategy=JsonParse::STANDARD)
static Json	parse (const char *in, std::string &err, JsonParse strategy=JsonParse::STANDARD)
static std::vector< Json >	parse_multi (const std::string &in, std::string::size_type &parser_stop_pos, std::string &err, JsonParse strategy=JsonParse::STANDARD)
static std::vector< Json >	parse_multi (const std::string &in, std::string &err, JsonParse strategy=JsonParse::STANDARD)

Private Attributes
std::shared_ptr< JsonValue >	m_ptr

Member Typedef Documentation

typedef std::vector<Json> json11::Json::array

typedef std::map<std::string, Json> json11::Json::object

typedef std::initializer_list<std::pair<std::string, Type> > json11::Json::shape

Member Enumeration Documentation

enum json11::Json::Type

Enumerator
NUL
NUMBER
BOOL
STRING
ARRAY
OBJECT

              {
        NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
    };

Constructor & Destructor Documentation

json11::Json::Json ( )

noexcept

: m_ptr(statics().null) {}

json11::Json::Json ( std::nullptr_t  )

noexcept

: m_ptr(statics().null) {}

json11::Json::Json

(

double

value

)

: m_ptr(make_shared<JsonDouble>(value)) {}

json11::Json::Json

(

int

value

)

: m_ptr(make_shared<JsonInt>(value)) {}

json11::Json::Json

(

bool

value

)

: m_ptr(value ? statics().t : statics().f) {}

json11::Json::Json

(

const std::string &

value

)

json11::Json::Json

(

std::string &&

value

)

json11::Json::Json

(

const char *

value

)

: m_ptr(make_shared<JsonString>(value)) {}

json11::Json::Json

(

const array &

values

)

: m_ptr(make_shared<JsonArray>(values)) {}

json11::Json::Json

(

Json::array &&

values

)

: m_ptr(make_shared<JsonArray>(move(values))) {}

json11::Json::Json

(

const object &

values

)

json11::Json::Json

(

object &&

values

)

template<class T , class = decltype(&T::to_json)>

json11::Json::Json ( const T &  t )

inline

: Json(t.to_json()) {}

template<class M , typename std::enable_if< std::is_constructible< std::string, decltype(std::declval< M >().begin() ->first)>::value &&std::is_constructible< Json, decltype(std::declval< M >().begin() -> second>

json11::Json::Json ( const M &  m )

inline

: Json(object(m.begin(), m.end())) {}

template<class V , typename std::enable_if< std::is_constructible< Json, decltype(*std::declval< V >().begin())>::value, int >::type = 0>

json11::Json::Json ( const V &  v )

inline

: Json(array(v.begin(), v.end())) {}

json11::Json::Json ( void *  )

delete

Member Function Documentation

Json::Type json11::Json::type

(

)

const

{ return m_ptr->type();         }

string json11::Json::type_name

(

)

const

                                                      { 
    if(m_ptr->type()==NUL)  return "NULL";
    if(m_ptr->type()==NUMBER) return "NUMBER";
    if(m_ptr->type()==BOOL) return "BOOL";
    if(m_ptr->type()==STRING) return "STRING";
    if(m_ptr->type()==ARRAY) return "ARRAY";
    if(m_ptr->type()==OBJECT) return "OBJECT";
    return "NULL";
}

bool json11::Json::is_null ( ) const

inline

{ return type() == NUL; }

bool json11::Json::is_number ( ) const

inline

{ return type() == NUMBER; }

bool json11::Json::is_bool ( ) const

inline

{ return type() == BOOL; }

bool json11::Json::is_string ( ) const

inline

{ return type() == STRING; }

bool json11::Json::is_array ( ) const

inline

{ return type() == ARRAY; }

bool json11::Json::is_object ( ) const

inline

{ return type() == OBJECT; }

double json11::Json::number_value

(

)

const

{ return m_ptr->number_value(); }

int json11::Json::int_value

(

)

const

{ return m_ptr->int_value();    }

bool json11::Json::bool_value

(

)

const

{ return m_ptr->bool_value();   }

const string & json11::Json::string_value

(

)

const

{ return m_ptr->string_value(); }

const vector< Json > & json11::Json::array_items

(

)

const

{ return m_ptr->array_items();  }

const map< string, Json > & json11::Json::object_items

(

)

const

{ return m_ptr->object_items(); }

const Json & json11::Json::operator[]

(

size_t

i

)

const

{ return (*m_ptr)[i];           }

const Json& json11::Json::operator[]

(

const std::string &

key

)

const

void json11::Json::dump

(

std::string &

out

)

const

std::string json11::Json::dump ( ) const

inline

                           {
        std::string out;
        dump(out);
        return out;
    }

static Json json11::Json::parse ( const std::string &  in, std::string &  err, JsonParse  strategy = JsonParse::STANDARD  )

static

static Json json11::Json::parse ( const char *  in, std::string &  err, JsonParse  strategy = JsonParse::STANDARD  )

inlinestatic

                                                              {
        if (in) {
            return parse(std::string(in), err, strategy);
        } else {
            err = "null input";
            return nullptr;
        }
    }

static std::vector<Json> json11::Json::parse_multi ( const std::string &  in, std::string::size_type &  parser_stop_pos, std::string &  err, JsonParse  strategy = JsonParse::STANDARD  )

static

static std::vector<Json> json11::Json::parse_multi ( const std::string &  in, std::string &  err, JsonParse  strategy = JsonParse::STANDARD  )

inlinestatic

                                                {
        std::string::size_type parser_stop_pos;
        return parse_multi(in, parser_stop_pos, err, strategy);
    }

bool json11::Json::operator==

(

const Json &

rhs

)

const

                                              {
    if (m_ptr == other.m_ptr)
        return true;
    if (m_ptr->type() != other.m_ptr->type())
        return false;

    return m_ptr->equals(other.m_ptr.get());
}

bool json11::Json::operator<

(

const Json &

rhs

)

const

                                             {
    if (m_ptr == other.m_ptr)
        return false;
    if (m_ptr->type() != other.m_ptr->type())
        return m_ptr->type() < other.m_ptr->type();

    return m_ptr->less(other.m_ptr.get());
}

bool json11::Json::operator!= ( const Json &  rhs ) const

inline

{ return !(*this == rhs); }

bool json11::Json::operator<= ( const Json &  rhs ) const

inline

{ return !(rhs < *this); }

bool json11::Json::operator> ( const Json &  rhs ) const

inline

{ return  (rhs < *this); }

bool json11::Json::operator>= ( const Json &  rhs ) const

inline

{ return !(*this < rhs); }

bool json11::Json::has_shape	(	const shape &	types,
		std::string &	err
	)		const

                                                            {
    if (!is_object()) {
        err = "expected JSON object, got " + dump();
        return false;
    }

    const auto& obj_items = object_items();
    for (auto & item : types) {
        const auto it = obj_items.find(item.first);
        if (it == obj_items.cend() || it->second.type() != item.second) {
            err = "bad type for " + item.first + " in " + dump();
            return false;
        }
    }

    return true;
}

Member Data Documentation

std::shared_ptr<JsonValue> json11::Json::m_ptr

private

---

The documentation for this class was generated from the following files:

• json11.hpp
• json11.cpp