Commit 5ffbcad3 authored by Swann Perarnau's avatar Swann Perarnau
Browse files

[refactor] Move third party code to its own dir

Jsonxx is an import of a third party code, with its own license. While
the licenses are compatible, moving that code to its own directory make
it easier to identify it as foreign.

This commit also remove the extra copy of the code that was in the
repository, and update the relevant Makefile rules.
parent 019687da
......@@ -21,7 +21,7 @@ CXX_SOURCES=argo_nodeos_config.cpp config_reader.cpp node_settup_changer.cpp
string_parser.cpp\
int_list_parser.cpp\
nodeos_exceptions.cpp\
jsonxx.cc
thirdparty/jsonxx/jsonxx.cc
CXX_HEADERS=config_reader.hpp node_setup_changer.hpp node_setup_reader.hpp \
argo_container.hpp container_manager.hpp utils.hpp acl.cpp \
......@@ -35,18 +35,18 @@ CXX_HEADERS=config_reader.hpp node_setup_changer.hpp node_setup_reader.hpp \
int_list_parser.hpp\
nodeos_exceptions.hpp\
resource_ownership.hpp\
jsonxx.h
thirdparty/jsonxx/jsonxx.h
OBJECTS=argo_nodeos_config.o config_reader.o node_settup_changer.o node_setup_reader.o \
argo_container.o utils.o container_manager.o acl.o ilogger.o stderrlogger.o\
syslogger.o filelogger.o aggregatelogger.o log_option_parser.o \
resource_locker.o trace.o \
iresource_controller.cpp\
iresource_controller_status.cpp\
iresource_controller.o\
iresource_controller_status.o\
string_parser.o\
int_list_parser.o\
nodeos_exceptions.o\
jsonxx.o
thirdparty/jsonxx/jsonxx.o
%.o: %.c %.h
$(CC) $(CFLAGS) -c $<
......@@ -62,7 +62,7 @@ $(BIN): $(OBJECTS)
chmod u+s $(BIN)
clean:
rm -f *.o $(BIN)
rm -f $(OBJECTS) $(BIN)
# DO NOT DELETE
argo_nodeos_config.o: headers.hpp acl.hpp utils.hpp /usr/include/sys/types.h
......@@ -450,9 +450,9 @@ int_list_parser.o: /usr/include/bits/sched.h /usr/include/bits/setjmp.h
int_list_parser.o: common.hpp /usr/include/sys/stat.h defaults.hpp
int_list_parser.o: /usr/include/syslog.h /usr/include/sys/syslog.h
int_list_parser.o: /usr/include/bits/syslog-path.h nodeos_exceptions.hpp
jsonxx.o: jsonxx.h /usr/include/stdio.h /usr/include/features.h
jsonxx.o: /usr/include/stdc-predef.h /usr/include/sys/cdefs.h
jsonxx.o: /usr/include/bits/wordsize.h /usr/include/gnu/stubs.h
jsonxx.o: /usr/include/bits/types.h /usr/include/bits/typesizes.h
jsonxx.o: /usr/include/libio.h /usr/include/_G_config.h /usr/include/wchar.h
jsonxx.o: /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h
thirdparty/jsonxx/jsonxx.o: thirdparty/jsonxx/jsonxx.h /usr/include/stdio.h /usr/include/features.h
thirdparty/jsonxx/jsonxx.o: /usr/include/stdc-predef.h /usr/include/sys/cdefs.h
thirdparty/jsonxx/jsonxx.o: /usr/include/bits/wordsize.h /usr/include/gnu/stubs.h
thirdparty/jsonxx/jsonxx.o: /usr/include/bits/types.h /usr/include/bits/typesizes.h
thirdparty/jsonxx/jsonxx.o: /usr/include/libio.h /usr/include/_G_config.h /usr/include/wchar.h
thirdparty/jsonxx/jsonxx.o: /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h
jsonxx_test
*.o
*~
CXXFLAGS=-Werror -Wall -g
jsonxx_test: jsonxx_test.cc jsonxx.o
jsonxx.o: jsonxx.h jsonxx.cc
test: jsonxx_test
./jsonxx_test
.PHONY: clean
clean:
rm -f jsonxx_test *.o *~
This diff is collapsed.
// -*- mode: c++; c-basic-offset: 4; -*-
// Author: Hong Jiang <hong@hjiang.net>
// Contributors:
// Sean Middleditch <sean@middleditch.us>
// rlyeh <https://github.com/r-lyeh>
#pragma once
#include <cassert>
#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <sstream>
// jsonxx versioning: major.minor-extra where
// major = { number }
// minor = { number }
// extra = { 'a':alpha, 'b':beta, 'rc': release candidate, 'r': release, 's':stable }
#define JSONXX_MAJOR "0"
#define JSONXX_MINOR "22"
#define JSONXX_EXTRA "a"
#define JSONXX_VERSION JSONXX_MAJOR "." JSONXX_MINOR "-" JSONXX_EXTRA
#define JSONXX_XML_TAG "<!-- generated by jsonxx " JSONXX_VERSION " -->"
#if __cplusplus > 199711L
#define JSONXX_COMPILER_HAS_CXX11 1
#elif defined(_MSC_VER) && _MSC_VER > 1700
#define JSONXX_COMPILER_HAS_CXX11 1
#else
#define JSONXX_COMPILER_HAS_CXX11 0
#endif
#define JSONXX_ASSERT(...) do { if( jsonxx::Assertions ) \
jsonxx::assertion(__FILE__,__LINE__,#__VA_ARGS__,bool(__VA_ARGS__)); } while(0)
namespace jsonxx {
// Settings
enum Settings {
// constants
Enabled = true,
Disabled = false,
Permissive = true,
Strict = false,
// values
Parser = Permissive, // permissive or strict parsing
UnquotedKeys = Disabled, // support of unquoted keys
Assertions = Enabled // enabled or disabled assertions (these asserts work both in DEBUG and RELEASE builds)
};
// Constants for .write() and .xml() methods
enum Format {
JSON = 0, // JSON output
JSONx = 1, // XML output, JSONx format. see http://goo.gl/I3cxs
JXML = 2, // XML output, JXML format. see https://github.com/r-lyeh/JXML
JXMLex = 3, // XML output, JXMLex format. see https://github.com/r-lyeh/JXMLex
TaggedXML = 4 // XML output, tagged XML format. see https://github.com/hjiang/jsonxx/issues/12
};
// Types
typedef long double Number;
typedef bool Boolean;
typedef std::string String;
struct Null {};
class Value;
class Object;
class Array;
// Identity meta-function
template <typename T>
struct identity {
typedef T type;
};
// Tools
bool validate( const std::string &input );
bool validate( std::istream &input );
std::string reformat( const std::string &input );
std::string reformat( std::istream &input );
std::string xml( const std::string &input, unsigned format = JSONx );
std::string xml( std::istream &input, unsigned format = JSONx );
// Detail
void assertion( const char *file, int line, const char *expression, bool result );
// A JSON Object
class Object {
public:
Object();
~Object();
template <typename T>
bool has(const std::string& key) const;
// Always call has<>() first. If the key doesn't exist, consider
// the behavior undefined.
template <typename T>
T& get(const std::string& key);
template <typename T>
const T& get(const std::string& key) const;
template <typename T>
const T& get(const std::string& key, const typename identity<T>::type& default_value) const;
size_t size() const;
bool empty() const;
const std::map<std::string, Value*>& kv_map() const;
std::string json() const;
std::string xml( unsigned format = JSONx, const std::string &header = std::string(), const std::string &attrib = std::string() ) const;
std::string write( unsigned format ) const;
void reset();
bool parse(std::istream &input);
bool parse(const std::string &input);
typedef std::map<std::string, Value*> container;
void import( const Object &other );
void import( const std::string &key, const Value &value );
Object &operator<<(const Value &value);
Object &operator<<(const Object &value);
Object &operator=(const Object &value);
Object(const Object &other);
Object(const std::string &key, const Value &value);
template<size_t N>
Object(const char (&key)[N], const Value &value) {
import(key,value);
}
template<typename T>
Object &operator<<(const T &value);
protected:
static bool parse(std::istream& input, Object& object);
container value_map_;
std::string odd;
};
class Array {
public:
Array();
~Array();
size_t size() const;
bool empty() const;
template <typename T>
bool has(unsigned int i) const;
template <typename T>
T& get(unsigned int i);
template <typename T>
const T& get(unsigned int i) const;
template <typename T>
const T& get(unsigned int i, const typename identity<T>::type& default_value) const;
const std::vector<Value*>& values() const {
return values_;
}
std::string json() const;
std::string xml( unsigned format = JSONx, const std::string &header = std::string(), const std::string &attrib = std::string() ) const;
std::string write( unsigned format ) const { return format == JSON ? json() : xml(format); }
void reset();
bool parse(std::istream &input);
bool parse(const std::string &input);
typedef std::vector<Value*> container;
void import(const Array &other);
void import(const Value &value);
Array &operator<<(const Array &other);
Array &operator<<(const Value &value);
Array &operator=(const Array &other);
Array &operator=(const Value &value);
Array(const Array &other);
Array(const Value &value);
protected:
static bool parse(std::istream& input, Array& array);
container values_;
};
// A value could be a number, an array, a string, an object, a
// boolean, or null
class Value {
public:
Value();
~Value() { reset(); }
void reset();
template<typename T>
void import( const T & ) {
reset();
type_ = INVALID_;
// debug
// std::cout << "[WARN] No support for " << typeid(t).name() << std::endl;
}
void import( const bool &b ) {
reset();
type_ = BOOL_;
bool_value_ = b;
}
#define $number(TYPE) \
void import( const TYPE &n ) { \
reset(); \
type_ = NUMBER_; \
number_value_ = static_cast<long double>(n); \
}
$number( char )
$number( int )
$number( long )
$number( long long )
$number( unsigned char )
$number( unsigned int )
$number( unsigned long )
$number( unsigned long long )
$number( float )
$number( double )
$number( long double )
#undef $number
#if JSONXX_COMPILER_HAS_CXX11 > 0
void import( const std::nullptr_t & ) {
reset();
type_ = NULL_;
}
#endif
void import( const Null & ) {
reset();
type_ = NULL_;
}
void import( const String &s ) {
reset();
type_ = STRING_;
*( string_value_ = new String() ) = s;
}
void import( const Array &a ) {
reset();
type_ = ARRAY_;
*( array_value_ = new Array() ) = a;
}
void import( const Object &o ) {
reset();
type_ = OBJECT_;
*( object_value_ = new Object() ) = o;
}
void import( const Value &other ) {
if (this != &other)
switch (other.type_) {
case NULL_:
import( Null() );
break;
case BOOL_:
import( other.bool_value_ );
break;
case NUMBER_:
import( other.number_value_ );
break;
case STRING_:
import( *other.string_value_ );
break;
case ARRAY_:
import( *other.array_value_ );
break;
case OBJECT_:
import( *other.object_value_ );
break;
case INVALID_:
type_ = INVALID_;
break;
default:
JSONXX_ASSERT( !"not implemented" );
}
}
template<typename T>
Value &operator <<( const T &t ) {
import(t);
return *this;
}
template<typename T>
Value &operator =( const T &t ) {
reset();
import(t);
return *this;
}
Value(const Value &other);
template<typename T>
Value( const T&t ) : type_(INVALID_) { import(t); }
template<size_t N>
Value( const char (&t)[N] ) : type_(INVALID_) { import( std::string(t) ); }
bool parse(std::istream &input);
bool parse(const std::string &input);
template<typename T>
bool is() const;
template<typename T>
T& get();
template<typename T>
const T& get() const;
bool empty() const;
public:
enum {
NUMBER_,
STRING_,
BOOL_,
NULL_,
ARRAY_,
OBJECT_,
INVALID_
} type_;
union {
Number number_value_;
String* string_value_;
Boolean bool_value_;
Array* array_value_;
Object* object_value_;
};
protected:
static bool parse(std::istream& input, Value& value);
};
template <typename T>
bool Array::has(unsigned int i) const {
if (i >= size()) {
return false;
} else {
Value* v = values_.at(i);
return v->is<T>();
}
}
template <typename T>
T& Array::get(unsigned int i) {
JSONXX_ASSERT(i < size());
Value* v = values_.at(i);
return v->get<T>();
}
template <typename T>
const T& Array::get(unsigned int i) const {
JSONXX_ASSERT(i < size());
const Value* v = values_.at(i);
return v->get<T>();
}
template <typename T>
const T& Array::get(unsigned int i, const typename identity<T>::type& default_value) const {
if(has<T>(i)) {
const Value* v = values_.at(i);
return v->get<T>();
} else {
return default_value;
}
}
template <typename T>
bool Object::has(const std::string& key) const {
container::const_iterator it(value_map_.find(key));
return it != value_map_.end() && it->second->is<T>();
}
template <typename T>
T& Object::get(const std::string& key) {
JSONXX_ASSERT(has<T>(key));
return value_map_.find(key)->second->get<T>();
}
template <typename T>
const T& Object::get(const std::string& key) const {
JSONXX_ASSERT(has<T>(key));
return value_map_.find(key)->second->get<T>();
}
template <typename T>
const T& Object::get(const std::string& key, const typename identity<T>::type& default_value) const {
if (has<T>(key)) {
return value_map_.find(key)->second->get<T>();
} else {
return default_value;
}
}
template<>
inline bool Value::is<Value>() const {
return true;
}
template<>
inline bool Value::is<Null>() const {
return type_ == NULL_;
}
template<>
inline bool Value::is<Boolean>() const {
return type_ == BOOL_;
}
template<>
inline bool Value::is<String>() const {
return type_ == STRING_;
}
template<>
inline bool Value::is<Number>() const {
return type_ == NUMBER_;
}
template<>
inline bool Value::is<Array>() const {
return type_ == ARRAY_;
}
template<>
inline bool Value::is<Object>() const {
return type_ == OBJECT_;
}
template<>
inline Value& Value::get<Value>() {
return *this;
}
template<>
inline const Value& Value::get<Value>() const {
return *this;
}
template<>
inline bool& Value::get<Boolean>() {
JSONXX_ASSERT(is<Boolean>());
return bool_value_;
}
template<>
inline std::string& Value::get<String>() {
JSONXX_ASSERT(is<String>());
return *string_value_;
}
template<>
inline Number& Value::get<Number>() {
JSONXX_ASSERT(is<Number>());
return number_value_;
}
template<>
inline Array& Value::get<Array>() {
JSONXX_ASSERT(is<Array>());
return *array_value_;
}
template<>
inline Object& Value::get<Object>() {
JSONXX_ASSERT(is<Object>());
return *object_value_;
}
template<>
inline const Boolean& Value::get<Boolean>() const {
JSONXX_ASSERT(is<Boolean>());
return bool_value_;
}
template<>
inline const String& Value::get<String>() const {
JSONXX_ASSERT(is<String>());
return *string_value_;
}
template<>
inline const Number& Value::get<Number>() const {
JSONXX_ASSERT(is<Number>());
return number_value_;
}
template<>
inline const Array& Value::get<Array>() const {
JSONXX_ASSERT(is<Array>());
return *array_value_;
}
template<>
inline const Object& Value::get<Object>() const {
JSONXX_ASSERT(is<Object>());
return *object_value_;
}
template<typename T>
inline Object &Object::operator<<(const T &value) {
return *this << Value(value), *this;
}
} // namespace jsonxx
std::ostream& operator<<(std::ostream& stream, const jsonxx::Value& v);
std::ostream& operator<<(std::ostream& stream, const jsonxx::Object& v);
std::ostream& operator<<(std::ostream& stream, const jsonxx::Array& v);
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment