FGCOM/jansson
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'cleanup-c++-code'

Browse Source
This commit is contained in:
Petri Lehtinen 2010-02-04 21:12:36 +02:00
commit 79e9dae9a0
6 changed files with 844 additions and 818 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.am
View File

@ -1,4 +1,4 @@
include_HEADERS = jansson.h jansson.hpp jansson-impl.hpp include_HEADERS = jansson.h jansson.hpp jansson.ipp
lib_LTLIBRARIES = libjansson.la lib_LTLIBRARIES = libjansson.la
libjansson_la_SOURCES = \ libjansson_la_SOURCES = \

469
src/jansson-impl.hpp
View File

@ -1,469 +0,0 @@
// Copyright (c) 2010 Sean Middleditch <sean@middleditch.us>
//
// Jansson is free software; you can redistribute it and/or modify
// it under the terms of the MIT license. See LICENSE for details.
#if !defined(IN_JANSSON_HPP)
# error "jansson-impl.hpp may only by included from jansson.hpp"
#endif
namespace json {
namespace _private {
// assignment operator
template <typename _Base>
ValueBase<_Base>& ValueBase<_Base>::operator=(const Value& value) {
_Base::operator=(value);
return *this;
}
// check value type
template <typename _Base>
bool ValueBase<_Base>::is_undefined() const {
return _Base::as_json() == 0;
}
template <typename _Base>
bool ValueBase<_Base>::is_object() const {
return json_is_object(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_array() const {
return json_is_array(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_string() const {
return json_is_string(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_integer() const {
return json_is_integer(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_real() const {
return json_is_real(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_number() const {
return json_is_number(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_true() const {
return json_is_true(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_false() const {
return json_is_false(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_boolean() const {
return json_is_boolean(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_null() const {
return json_is_null(_Base::as_json());
}
// get size of array or object
template <typename _Base>
unsigned int ValueBase<_Base>::size() const {
if (is_object())
return json_object_size(_Base::as_json());
else
return json_array_size(_Base::as_json());
}
// get value at array index (const version)
template <typename _Base>
const Value ValueBase<_Base>::at(unsigned int index) const {
return Value(json_array_get(_Base::as_json(), index));
}
template <typename _Base>
const Value ValueBase<_Base>::operator[](signed int index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](unsigned int index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](signed short index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](unsigned short index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](signed long index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](unsigned long index) const { return at(index); }
// get value at array index (non-const version)
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::at(unsigned int index) {
return ElementProxy(_Base::as_json(), index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed int index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned int index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed short index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned short index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed long index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned long index) {
return at(index);
}
// get object property (const version)
template <typename _Base>
const Value ValueBase<_Base>::get(const char* key) const {
return Value(json_object_get(_Base::as_json(), key));
}
template <typename _Base>
const Value ValueBase<_Base>::get(const std::string& key) const {
return get(key.c_str());
}
template <typename _Base>
const Value ValueBase<_Base>::operator[](const char* key) const {
return get(key);
}
template <typename _Base>
const Value ValueBase<_Base>::operator[](const std::string& key) const {
return get(key.c_str());
}
// get object property (non-const version)
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::get(const char* key) {
return PropertyProxy(_Base::as_json(), key);
}
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::get(const std::string& key) {
return get(key.c_str());
}
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::operator[](const char* key) {
return get(key);
}
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::operator[](const std::string& key) {
return get(key.c_str());
}
// clear all array/object values
template <typename _Base>
void ValueBase<_Base>::clear() {
if (is_object())
json_object_clear(_Base::as_json());
else
json_array_clear(_Base::as_json());
}
// get value cast to specified type
template <typename _Base>
const char* ValueBase<_Base>::as_cstring() const {
return json_string_value(_Base::as_json());
}
template <typename _Base>
std::string ValueBase<_Base>::as_string() const {
const char* tmp = as_cstring();
return tmp == 0 ? "" : tmp;
}
template <typename _Base>
int ValueBase<_Base>::as_integer() const {
return json_integer_value(_Base::as_json());
}
template <typename _Base>
double ValueBase<_Base>::as_real() const {
return json_real_value(_Base::as_json());
}
template <typename _Base>
double ValueBase<_Base>::as_number() const {
return json_number_value(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::as_boolean() const {
return is_true();
}
// set an object property (converts value to object is not one already)
template <typename _Base>
_Base& ValueBase<_Base>::set_key(const char* key, const Value& value) {
json_object_set(_Base::as_json(), key, value._Base::as_json());
return *this;
}
template <typename _Base>
_Base& ValueBase<_Base>::set_key(const std::string& key, const Value& value) {
return set_key(key.c_str(), value);
}
// set an array index (converts value to object is not one already)
template <typename _Base>
_Base& ValueBase<_Base>::set_at(unsigned int index, const Value& value) {
if (index == size())
json_array_append(_Base::as_json(), value._Base::as_json());
else
json_array_set(_Base::as_json(), index, value._Base::as_json());
return *this;
}
// delete an object key
template <typename _Base>
_Base& ValueBase<_Base>::del_key(const char* key) {
json_object_del(_Base::as_json(), key);
return *this;
}
template <typename _Base>
_Base& ValueBase<_Base>::del_key(const std::string& key) {
return del_key(key.c_str());
}
// delete an item from an array by index
template <typename _Base>
_Base& ValueBase<_Base>::del_at(unsigned int index) {
json_array_remove(_Base::as_json(), index);
return *this;
}
// insert an item into an array at a given index
template <typename _Base>
_Base& ValueBase<_Base>::insert_at(unsigned int index, const Value& value) {
json_array_insert(_Base::as_json(), index, value._Base::as_json());
return *this;
}
// write the value to a file
template <typename _Base>
int ValueBase<_Base>::save_file(const char* path, int flags) const {
return json_dump_file(_Base::as_json(), path, flags);
}
// write the value to a string (caller must deallocate with free()!)
template <typename _Base>
char* ValueBase<_Base>::save_string(int flags) const {
return json_dumps(_Base::as_json(), flags);
}
Basic::~Basic() {
json_decref(_value);
}
// copy an existing Value
Basic& Basic::operator=(const Basic& e) {
if (&e != this) {
json_decref(_value);
_value = json_incref(e._value);
}
return *this;
}
// get the underlying json_t
json_t* Basic::as_json() const {
return _value;
}
// take ownership of a json_t (does not increase reference count)
Basic Basic::take_ownership(json_t* json) {
Basic v;
v._value = json;
return v;
}
// assign value to proxied array element
ElementProxy& ElementProxy::operator=(const Value& value) {
json_array_set(_array, _index, value.as_json());
return *this;
}
// get the proxied element
json_t* ElementProxy::as_json() const {
return json_array_get(_array, _index);
}
// assign value to proxied object property
PropertyProxy& PropertyProxy::operator=(const Value& value) {
json_object_set(_object, _key, value.as_json());
return *this;
}
json_t* PropertyProxy::as_json() const {
return json_object_get(_object, _key);
}
} // namespace json::_private
// construct Value::Value input
Value::Value(const char* value) {
_value = json_string(value);
}
Value::Value(const std::string& value) {
_value = json_string(value.c_str());
}
Value::Value(bool value) {
_value = value ? json_true() : json_false();
}
Value::Value(signed int value) {
_value = json_integer(value);
}
Value::Value(unsigned int value) {
_value = json_integer(value);
}
Value::Value(signed short value) {
_value = json_integer(value);
}
Value::Value(unsigned short value) {
_value = json_integer(value);
}
Value::Value(signed long value) {
_value = json_integer(value);
}
Value::Value(unsigned long value) {
_value = json_integer(value);
}
Value::Value(float value) {
_value = json_real(value);
}
Value::Value(double value) {
_value = json_real(value);
}
// construct a new iterator for a given object
Iterator::Iterator(const Value& value) : _object(value), _iter(0) {
_iter = json_object_iter(_object.as_json());
}
// construct a new iterator for a given object
Iterator::Iterator(const _private::ValueBase<_private::PropertyProxy>& value) :
_object(value.as_json()), _iter(0) {
_iter = json_object_iter(_object.as_json());
}
// increment iterator
void Iterator::next() {
_iter = json_object_iter_next(_object.as_json(), _iter);
}
Iterator& Iterator::operator++() { next(); return *this; }
// test if iterator is still valid
bool Iterator::valid() const {
return _iter != 0;
}
Iterator::operator bool() const {
return valid();
}
// get key
const char* Iterator::ckey() const {
return json_object_iter_key(_iter);
}
std::string Iterator::key() const {
return ckey();
}
// get value
const Value Iterator::value() const {
return Value(json_object_iter_value(_iter));
}
// dereference value
const Value Iterator::operator*() const {
return value();
}
// create a new empty object
Value object() {
return Value::take_ownership(json_object());
}
// create a new empty array
Value array() {
return Value::take_ownership(json_array());
}
// create a new null value
Value null() {
return Value::take_ownership(json_null());
}
// load a file as a JSON value
Value load_file(const char* path, json_error_t* error) {
return Value::take_ownership(json_load_file(path, error));
}
// load a string as a JSON value
Value load_string(const char* string, json_error_t* error) {
return Value::take_ownership(json_loads(string, error));
}
} // namespace json
// stream JSON value out
std::ostream& operator<<(std::ostream& os, const json::Value& value) {
// get the temporary serialize string
char* tmp = value.save_string();
if (tmp != 0) {
// stream temp string out and release it
os << tmp;
free(tmp);
}
return os;
}
// read JSON value
std::istream& operator>>(std::istream& is, json::Value& value) {
// buffer the remaining bytes into a single string for Jansson
std::stringstream tmp;
while (is)
tmp << static_cast<char>(is.get());
// parse the buffered string
value = json::load_string(tmp.str().c_str());
return is;
}

43
src/jansson.hpp
View File

@ -1,26 +1,32 @@
// Copyright (c) 2010 Sean Middleditch <sean@middleditch.us> // Copyright (c) 2010 Sean Middleditch <sean@middleditch.us>
// Copyright (c) 2010 Petri Lehtinen <petri@digip.org>
// //
// Jansson is free software; you can redistribute it and/or modify // Jansson is free software; you can redistribute it and/or modify
// it under the terms of the MIT license. See LICENSE for details. // it under the terms of the MIT license. See LICENSE for details.
#if !defined(JANSSON_HPP) #ifndef JANSSON_HPP
#define JANSSON_HPP 1 #define JANSSON_HPP
#include <string> #include <string>
#include <ostream> #include <ostream>
#include <istream> #include <istream>
#include <sstream> #include <sstream>
// Included so that standard functions don't end up in namespace json
#include <cstdio>
// For free()
#include <cstdlib> #include <cstdlib>
namespace json { namespace json {
// include Jansson C library into the json namespace // include Jansson C library into the json namespace
#include <jansson.h> # include <jansson.h>
class Iterator; class Iterator;
class Value; class Value;
// implementation details; do not use directly // implementation details; do not use directly
namespace _private { namespace detail {
class ElementProxy; class ElementProxy;
class PropertyProxy; class PropertyProxy;
@ -121,10 +127,11 @@ namespace json {
inline _Base& insert_at(unsigned int index, const Value& value); inline _Base& insert_at(unsigned int index, const Value& value);
// write the value to a file // write the value to a file
inline int save_file(const char* path, int flags = 0) const; inline int dump_file(const char* path, int flags = 0) const;
inline int dump_file(const std::string& path, int flags = 0) const;
// write the value to a string (caller must deallocate with free()!) // write the value to a string (caller must deallocate with free()!)
inline char* save_string(int flags = 0) const; inline char* dumps(int flags = 0) const;
}; };
// represents any JSON value, private base // represents any JSON value, private base
@ -196,10 +203,10 @@ namespace json {
const char* _key; const char* _key;
}; };
} // namespace json::_private } // namespace json::detail
// represents any JSON value // represents any JSON value
class Value : public _private::ValueBase<_private::Basic> { class Value : public detail::ValueBase<detail::Basic> {
public: public:
// construct Value from input // construct Value from input
explicit inline Value(const char* value); explicit inline Value(const char* value);
@ -215,19 +222,19 @@ namespace json {
explicit inline Value(double value); explicit inline Value(double value);
// empty constructor // empty constructor
Value() : _private::ValueBase<_private::Basic>() {} Value() : detail::ValueBase<detail::Basic>() {}
// copy constructor for base // copy constructor for base
Value(const _private::Basic& value) : _private::ValueBase<_private::Basic>(value) {} Value(const detail::Basic& value) : detail::ValueBase<detail::Basic>(value) {}
// copy constructor for base // copy constructor for base
Value(const _private::ValueBase<_private::Basic>& value) : _private::ValueBase<_private::Basic>(value) {} Value(const detail::ValueBase<detail::Basic>& value) : detail::ValueBase<detail::Basic>(value) {}
// copy constructor // copy constructor
Value(const Value& value) : _private::ValueBase<_private::Basic>(value) {} Value(const Value& value) : detail::ValueBase<detail::Basic>(value) {}
// create reference to value // create reference to value
explicit Value(json_t* json) : _private::ValueBase<_private::Basic>(json) {} explicit Value(json_t* json) : detail::ValueBase<detail::Basic>(json) {}
}; };
// iterators over a JSON object // iterators over a JSON object
@ -237,7 +244,7 @@ namespace json {
inline Iterator(const Value& value); inline Iterator(const Value& value);
// construct a new iterator for a given object // construct a new iterator for a given object
inline Iterator(const _private::ValueBase<_private::PropertyProxy>& value); inline Iterator(const detail::ValueBase<detail::PropertyProxy>& value);
// increment iterator // increment iterator
inline void next(); inline void next();
@ -283,9 +290,11 @@ namespace json {
// load a file as a JSON value // load a file as a JSON value
inline Value load_file(const char* path, json_error_t* error = 0); inline Value load_file(const char* path, json_error_t* error = 0);
inline Value load_file(const std::string& path, json_error_t* error = 0);
// load a string as a JSON value // load a string as a JSON value
inline Value load_string(const char* string, json_error_t* error = 0); inline Value loads(const char* string, json_error_t* error = 0);
inline Value loads(const std::string& string, json_error_t* error = 0);
} // namespace json } // namespace json
@ -296,8 +305,8 @@ inline std::ostream& operator<<(std::ostream& os, const json::Value& value);
inline std::istream& operator>>(std::istream& is, json::Value& value); inline std::istream& operator>>(std::istream& is, json::Value& value);
// include implementation code // include implementation code
#define IN_JANSSON_HPP 1 #define IN_JANSSON_HPP
#include "jansson-impl.hpp" #include "jansson.ipp"
#undef IN_JANSSON_HPP #undef IN_JANSSON_HPP
#endif // defined(JANSSON_HPP) #endif // defined(JANSSON_HPP)

483
src/jansson.ipp Normal file
View File

@ -0,0 +1,483 @@
// Copyright (c) 2010 Sean Middleditch <sean@middleditch.us>
// Copyright (c) 2010 Petri Lehtinen <petri@digip.org>
//
// Jansson is free software; you can redistribute it and/or modify
// it under the terms of the MIT license. See LICENSE for details.
#ifndef IN_JANSSON_HPP
#error "jansson.ipp may only be included from jansson.hpp"
#endif
namespace json {
namespace detail {
// assignment operator
template <typename _Base>
ValueBase<_Base>& ValueBase<_Base>::operator=(const Value& value) {
_Base::operator=(value);
return *this;
}
// check value type
template <typename _Base>
bool ValueBase<_Base>::is_undefined() const {
return _Base::as_json() == 0;
}
template <typename _Base>
bool ValueBase<_Base>::is_object() const {
return json_is_object(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_array() const {
return json_is_array(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_string() const {
return json_is_string(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_integer() const {
return json_is_integer(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_real() const {
return json_is_real(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_number() const {
return json_is_number(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_true() const {
return json_is_true(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_false() const {
return json_is_false(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_boolean() const {
return json_is_boolean(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::is_null() const {
return json_is_null(_Base::as_json());
}
// get size of array or object
template <typename _Base>
unsigned int ValueBase<_Base>::size() const {
if (is_object())
return json_object_size(_Base::as_json());
else
return json_array_size(_Base::as_json());
}
// get value at array index (const version)
template <typename _Base>
const Value ValueBase<_Base>::at(unsigned int index) const {
return Value(json_array_get(_Base::as_json(), index));
}
template <typename _Base>
const Value ValueBase<_Base>::operator[](signed int index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](unsigned int index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](signed short index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](unsigned short index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](signed long index) const { return at(index); }
template <typename _Base>
const Value ValueBase<_Base>::operator[](unsigned long index) const { return at(index); }
// get value at array index (non-const version)
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::at(unsigned int index) {
return ElementProxy(_Base::as_json(), index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed int index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned int index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed short index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned short index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed long index) {
return at(index);
}
template <typename _Base>
ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned long index) {
return at(index);
}
// get object property (const version)
template <typename _Base>
const Value ValueBase<_Base>::get(const char* key) const {
return Value(json_object_get(_Base::as_json(), key));
}
template <typename _Base>
const Value ValueBase<_Base>::get(const std::string& key) const {
return get(key.c_str());
}
template <typename _Base>
const Value ValueBase<_Base>::operator[](const char* key) const {
return get(key);
}
template <typename _Base>
const Value ValueBase<_Base>::operator[](const std::string& key) const {
return get(key.c_str());
}
// get object property (non-const version)
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::get(const char* key) {
return PropertyProxy(_Base::as_json(), key);
}
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::get(const std::string& key) {
return get(key.c_str());
}
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::operator[](const char* key) {
return get(key);
}
template <typename _Base>
ValueBase<PropertyProxy> ValueBase<_Base>::operator[](const std::string& key) {
return get(key.c_str());
}
// clear all array/object values
template <typename _Base>
void ValueBase<_Base>::clear() {
if (is_object())
json_object_clear(_Base::as_json());
else
json_array_clear(_Base::as_json());
}
// get value cast to specified type
template <typename _Base>
const char* ValueBase<_Base>::as_cstring() const {
return json_string_value(_Base::as_json());
}
template <typename _Base>
std::string ValueBase<_Base>::as_string() const {
const char* tmp = as_cstring();
return tmp == 0 ? "" : tmp;
}
template <typename _Base>
int ValueBase<_Base>::as_integer() const {
return json_integer_value(_Base::as_json());
}
template <typename _Base>
double ValueBase<_Base>::as_real() const {
return json_real_value(_Base::as_json());
}
template <typename _Base>
double ValueBase<_Base>::as_number() const {
return json_number_value(_Base::as_json());
}
template <typename _Base>
bool ValueBase<_Base>::as_boolean() const {
return is_true();
}
// set an object property (converts value to object is not one already)
template <typename _Base>
_Base& ValueBase<_Base>::set_key(const char* key, const Value& value) {
json_object_set(_Base::as_json(), key, value._Base::as_json());
return *this;
}
template <typename _Base>
_Base& ValueBase<_Base>::set_key(const std::string& key, const Value& value) {
return set_key(key.c_str(), value);
}
// set an array index (converts value to object is not one already)
template <typename _Base>
_Base& ValueBase<_Base>::set_at(unsigned int index, const Value& value) {
if (index == size())
json_array_append(_Base::as_json(), value._Base::as_json());
else
json_array_set(_Base::as_json(), index, value._Base::as_json());
return *this;
}
// delete an object key
template <typename _Base>
_Base& ValueBase<_Base>::del_key(const char* key) {
json_object_del(_Base::as_json(), key);
return *this;
}
template <typename _Base>
_Base& ValueBase<_Base>::del_key(const std::string& key) {
return del_key(key.c_str());
}
// delete an item from an array by index
template <typename _Base>
_Base& ValueBase<_Base>::del_at(unsigned int index) {
json_array_remove(_Base::as_json(), index);
return *this;
}
// insert an item into an array at a given index
template <typename _Base>
_Base& ValueBase<_Base>::insert_at(unsigned int index, const Value& value) {
json_array_insert(_Base::as_json(), index, value._Base::as_json());
return *this;
}
// write the value to a file
template <typename _Base>
int ValueBase<_Base>::dump_file(const char* path, int flags) const {
return json_dump_file(_Base::as_json(), path, flags);
}
template <typename _Base>
int ValueBase<_Base>::dump_file(const std::string& path, int flags) const {
return dump_file(path.c_str(), flags);
}
// write the value to a string (caller must deallocate with free()!)
template <typename _Base>
char* ValueBase<_Base>::dumps(int flags) const {
return json_dumps(_Base::as_json(), flags);
}
Basic::~Basic() {
json_decref(_value);
}
// copy an existing Value
Basic& Basic::operator=(const Basic& e) {
if (&e != this) {
json_decref(_value);
_value = json_incref(e._value);
}
return *this;
}
// get the underlying json_t
json_t* Basic::as_json() const {
return _value;
}
// take ownership of a json_t (does not increase reference count)
Basic Basic::take_ownership(json_t* json) {
Basic v;
v._value = json;
return v;
}
// assign value to proxied array element
ElementProxy& ElementProxy::operator=(const Value& value) {
json_array_set(_array, _index, value.as_json());
return *this;
}
// get the proxied element
json_t* ElementProxy::as_json() const {
return json_array_get(_array, _index);
}
// assign value to proxied object property
PropertyProxy& PropertyProxy::operator=(const Value& value) {
json_object_set(_object, _key, value.as_json());
return *this;
}
json_t* PropertyProxy::as_json() const {
return json_object_get(_object, _key);
}
} // namespace json::detail
// construct Value::Value input
Value::Value(const char* value) {
_value = json_string(value);
}
Value::Value(const std::string& value) {
_value = json_string(value.c_str());
}
Value::Value(bool value) {
_value = value ? json_true() : json_false();
}
Value::Value(signed int value) {
_value = json_integer(value);
}
Value::Value(unsigned int value) {
_value = json_integer(value);
}
Value::Value(signed short value) {
_value = json_integer(value);
}
Value::Value(unsigned short value) {
_value = json_integer(value);
}
Value::Value(signed long value) {
_value = json_integer(value);
}
Value::Value(unsigned long value) {
_value = json_integer(value);
}
Value::Value(float value) {
_value = json_real(value);
}
Value::Value(double value) {
_value = json_real(value);
}
// construct a new iterator for a given object
Iterator::Iterator(const Value& value) : _object(value), _iter(0) {
_iter = json_object_iter(_object.as_json());
}
// construct a new iterator for a given object
Iterator::Iterator(const detail::ValueBase<detail::PropertyProxy>& value) :
_object(value.as_json()), _iter(0) {
_iter = json_object_iter(_object.as_json());
}
// increment iterator
void Iterator::next() {
_iter = json_object_iter_next(_object.as_json(), _iter);
}
Iterator& Iterator::operator++() { next(); return *this; }
// test if iterator is still valid
bool Iterator::valid() const {
return _iter != 0;
}
Iterator::operator bool() const {
return valid();
}
// get key
const char* Iterator::ckey() const {
return json_object_iter_key(_iter);
}
std::string Iterator::key() const {
return ckey();
}
// get value
const Value Iterator::value() const {
return Value(json_object_iter_value(_iter));
}
// dereference value
const Value Iterator::operator*() const {
return value();
}
// create a new empty object
Value object() {
return Value::take_ownership(json_object());
}
// create a new empty array
Value array() {
return Value::take_ownership(json_array());
}
// create a new null value
Value null() {
return Value::take_ownership(json_null());
}
// load a file as a JSON value
Value load_file(const char* path, json_error_t* error) {
return Value::take_ownership(json_load_file(path, error));
}
Value load_file(const std::string& path, json_error_t* error) {
return load_file(path.c_str(), error);
}
// load a string as a JSON value
Value loads(const char* string, json_error_t* error) {
return Value::take_ownership(json_loads(string, error));
}
Value loads(const std::string& string, json_error_t* error) {
return loads(string.c_str(), error);
}
} // namespace json
// stream JSON value out
std::ostream& operator<<(std::ostream& os, const json::Value& value) {
// get the temporary serialize string
char* tmp = value.dumps();
if (tmp != 0) {
// stream temp string out and release it
os << tmp;
free(tmp);
}
return os;
}
// read JSON value
std::istream& operator>>(std::istream& is, json::Value& value) {
// buffer the remaining bytes into a single string for Jansson
std::stringstream tmp;
while (is)
tmp << static_cast<char>(is.get());
// parse the buffered string
value = json::loads(tmp.str().c_str());
return is;
}

17
test/suites/api/test_cpp.cpp
View File

@ -1,6 +1,5 @@
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <malloc.h>
#include "jansson.hpp" #include "jansson.hpp"
@ -8,9 +7,12 @@
do { \ do { \
if(!((lhs) op (rhs))) { \ if(!((lhs) op (rhs))) { \
std::cerr << std::boolalpha; \ std::cerr << std::boolalpha; \
std::cerr << __FILE__ << '[' << __LINE__ << "]: ERROR: " << (m) << std::endl; \ std::cerr << __FILE__ << '[' << __LINE__ << "]: ERROR: " \
std::cerr << "\ttest: " << #lhs << ' ' << #op << ' ' << #rhs << std::endl; \ << (m) << std::endl; \
std::cerr << "\tresult: " << (lhs) << ' ' << #op << ' ' << (rhs) << std::endl; \ std::cerr << "\ttest: " << #lhs << ' ' << #op << ' ' \
<< #rhs << std::endl; \
std::cerr << "\tresult: " << (lhs) << ' ' << #op << ' ' \
<< (rhs) << std::endl; \
return 1; \ return 1; \
} \ } \
} while(0) } while(0)
@ -20,10 +22,11 @@
#define ASSERT_FALSE(p, m) ASSERT_OP(p, true, !=, m) #define ASSERT_FALSE(p, m) ASSERT_OP(p, true, !=, m)
int main() { int main() {
json::Value e1(json::load_file("suites/api/test.json")); std::string top_srcdir = getenv("top_srcdir");
json::Value e1(json::load_file(top_srcdir + "/test/suites/api/test_cpp.json"));
json::Value e2(e1); json::Value e2(e1);
json::Value e3; json::Value e3;
json::Value e4(json::load_string("{\"foo\": true, \"bar\": \"test\"}")); json::Value e4(json::loads("{\"foo\": true, \"bar\": \"test\"}"));
ASSERT_TRUE(e1.is_object(), "e1 is not an object"); ASSERT_TRUE(e1.is_object(), "e1 is not an object");
ASSERT_TRUE(e2.is_object(), "e2 is not an object"); ASSERT_TRUE(e2.is_object(), "e2 is not an object");
@ -123,7 +126,7 @@ int main() {
json::Value e12(json::object()); json::Value e12(json::object());
e12.set_key("foo", json::Value("test")); e12.set_key("foo", json::Value("test"));
e12.set_key("bar", json::Value(3)); e12.set_key("bar", json::Value(3));
char* out_cstr = e12.save_string(0); char* out_cstr = e12.dumps(0);
std::string out(out_cstr); std::string out(out_cstr);
free(out_cstr); free(out_cstr);
ASSERT_EQ(out, "{\"bar\": 3, \"foo\": \"test\"}", "object did not serialize as expected"); ASSERT_EQ(out, "{\"bar\": 3, \"foo\": \"test\"}", "object did not serialize as expected");

0
test/suites/api/test.json → test/suites/api/test_cpp.json
View File