src/jansson.hpp

   1 // Copyright (c) 2010 Sean Middleditch <sean@middleditch.us>
   2 //
   3 // Jansson is free software; you can redistribute it and/or modify
   4 // it under the terms of the MIT license. See LICENSE for details.
   5
   6 #if !defined(JANSSON_HPP)
   7 #define JANSSON_HPP 1
   8
   9 #include <string>
  10 #include <ostream>
  11 #include <istream>
  12 #include <sstream>
  13 #include <cstdlib>
  14
  15 namespace json {
  16         // include Jansson C library into the json namespace
  17         #include <jansson.h>
  18
  19         class Iterator;
  20         class Value;
  21
  22         // implementation details; do not use directly
  23         namespace _private {
  24                 class ElementProxy;
  25                 class PropertyProxy;
  26
  27                 // base class for JSON value interface
  28                 template <typename _Base>
  29                 class ValueBase : public _Base {
  30                 public:
  31                         // empty constructor
  32                         ValueBase() : _Base() {}
  33
  34                         // copy constructor
  35                         ValueBase(const _Base& base) : _Base(base) {}
  36
  37                         // create reference to value
  38                         ValueBase(json_t* json) : _Base(json) {}
  39
  40                         // assignment operator
  41                         inline ValueBase& operator=(const Value& value);
  42
  43                         // check value type
  44                         inline bool is_undefined() const;
  45                         inline bool is_object() const;
  46                         inline bool is_array() const;
  47                         inline bool is_string() const;
  48                         inline bool is_integer() const;
  49                         inline bool is_real() const;
  50                         inline bool is_number() const;
  51                         inline bool is_true() const;
  52                         inline bool is_false() const;
  53                         inline bool is_boolean() const;
  54                         inline bool is_null() const;
  55
  56                         // get size of array or object
  57                         inline unsigned int size() const;
  58
  59                         // get value at array index (const version)
  60                         inline const Value at(unsigned int index) const;
  61
  62                         inline const Value operator[](signed int index) const;
  63                         inline const Value operator[](unsigned int index) const;
  64                         inline const Value operator[](signed short index) const;
  65                         inline const Value operator[](unsigned short index) const;
  66                         inline const Value operator[](signed long index) const;
  67                         inline const Value operator[](unsigned long index) const;
  68
  69                         // get value at array index (non-const version)
  70                         inline ValueBase<ElementProxy> at(unsigned int index);
  71
  72                         inline ValueBase<ElementProxy> operator[](signed int index);
  73                         inline ValueBase<ElementProxy> operator[](unsigned int index);
  74                         inline ValueBase<ElementProxy> operator[](signed short index);
  75                         inline ValueBase<ElementProxy> operator[](unsigned short index);
  76                         inline ValueBase<ElementProxy> operator[](signed long index);
  77                         inline ValueBase<ElementProxy> operator[](unsigned long index);
  78
  79                         // get object property (const version)
  80                         inline const Value get(const char* key) const;
  81
  82                         inline const Value get(const std::string& key) const;
  83                         inline const Value operator[](const char* key) const;
  84                         inline const Value operator[](const std::string& key) const;
  85
  86                         // get object property (non-const version)
  87                         inline ValueBase<PropertyProxy> get(const char* key);
  88
  89                         inline ValueBase<PropertyProxy> get(const std::string& key);
  90                         inline ValueBase<PropertyProxy> operator[](const char* key);
  91                         inline ValueBase<PropertyProxy> operator[](const std::string& key);
  92
  93                         // clear all array/object values
  94                         inline void clear();
  95
  96                         // get value cast to specified type
  97                         inline const char* as_cstring() const;
  98                         inline std::string as_string() const;
  99                         inline int as_integer() const;
 100                         inline double as_real() const;
 101                         inline double as_number() const;
 102                         inline bool as_boolean() const;
 103
 104                         // set an object property (converts value to object is not one already)
 105                         inline _Base& set_key(const char* key, const Value& value);
 106
 107                         inline _Base& set_key(const std::string& key, const Value& value);
 108
 109                         // set an array index (converts value to object is not one already)
 110                         inline _Base& set_at(unsigned int index, const Value& value);
 111
 112                         // delete an object key
 113                         inline _Base& del_key(const char* key);
 114
 115                         inline _Base& del_key(const std::string& key);
 116
 117                         // delete an item from an array by index
 118                         inline _Base& del_at(unsigned int index);
 119
 120                         // insert an item into an array at a given index
 121                         inline _Base& insert_at(unsigned int index, const Value& value);
 122
 123                         // write the value to a file
 124                         inline int save_file(const char* path, int flags = 0) const;
 125
 126                         // write the value to a string (caller must deallocate with free()!)
 127                         inline char* save_string(int flags = 0) const;
 128                 };
 129
 130                 // represents any JSON value, private base
 131                 class Basic {
 132                 public:
 133                         // construct new Value with an undefined value
 134                         Basic() : _value(0) {}
 135
 136                         // copy constructor
 137                         Basic(const Basic& value) : _value(json_incref(value._value)) {}
 138
 139                         // make a reference to an existing json_t value
 140                         explicit Basic(json_t* value) : _value(json_incref(value)) {}
 141
 142                         // free Value resources
 143                         inline ~Basic();
 144
 145                         // copy an existing Value
 146                         inline Basic& operator=(const Basic& e);
 147
 148                         // get the underlying json_t
 149                         inline json_t* as_json() const;
 150
 151                         // take ownership of a json_t (does not increase reference count)
 152                         inline static Basic take_ownership(json_t* json);
 153
 154                 protected:
 155                         // internal value pointer
 156                         json_t* _value;
 157                 };
 158
 159                 // proxies an array element
 160                 class ElementProxy {
 161                 public:
 162                         // constructor
 163                         ElementProxy(json_t* array, unsigned int index) : _array(array), _index(index) {}
 164
 165                         // assign to the proxied element
 166                         inline ElementProxy& operator=(const Value& value);
 167
 168                         // get the proxied element
 169                         inline json_t* as_json() const;
 170
 171                 private:
 172                         // array object we wrap
 173                         json_t* _array;
 174
 175                         // index of property
 176                         unsigned int _index;
 177                 };
 178
 179                 // proxies an object property
 180                 class PropertyProxy {
 181                 public:
 182                         // constructor
 183                         PropertyProxy(json_t* array, const char* key) : _object(array), _key(key) {}
 184
 185                         // assign to the proxied element
 186                         inline PropertyProxy& operator=(const Value& value);
 187
 188                         // get the proxied element
 189                         inline json_t* as_json() const;
 190
 191                 private:
 192                         // array object we wrap
 193                         json_t* _object;
 194
 195                         // key of property
 196                         const char* _key;
 197                 };
 198
 199         } // namespace json::_private
 200
 201         // represents any JSON value
 202         class Value : public _private::ValueBase<_private::Basic> {
 203         public:
 204                 // construct Value from input
 205                 explicit inline Value(const char* value);
 206                 explicit inline Value(const std::string& value);
 207                 explicit inline Value(bool value);
 208                 explicit inline Value(signed int value);
 209                 explicit inline Value(unsigned int value);
 210                 explicit inline Value(signed short value);
 211                 explicit inline Value(unsigned short value);
 212                 explicit inline Value(signed long value);
 213                 explicit inline Value(unsigned long value);
 214                 explicit inline Value(float value);
 215                 explicit inline Value(double value);
 216
 217                 // empty constructor
 218                 Value() : _private::ValueBase<_private::Basic>() {}
 219
 220                 // copy constructor for base
 221                 Value(const _private::Basic& value) : _private::ValueBase<_private::Basic>(value) {}
 222
 223                 // copy constructor for base
 224                 Value(const _private::ValueBase<_private::Basic>& value) : _private::ValueBase<_private::Basic>(value) {}
 225
 226                 // copy constructor
 227                 Value(const Value& value) : _private::ValueBase<_private::Basic>(value) {}
 228
 229                 // create reference to value
 230                 explicit Value(json_t* json) : _private::ValueBase<_private::Basic>(json) {}
 231         };
 232
 233         // iterators over a JSON object
 234         class Iterator {
 235         public:
 236                 // construct a new iterator for a given object
 237                 inline Iterator(const Value& value);
 238
 239                 // construct a new iterator for a given object
 240                 inline Iterator(const _private::ValueBase<_private::PropertyProxy>& value);
 241
 242                 // increment iterator
 243                 inline void next();
 244
 245                 inline Iterator& operator++();
 246
 247                 // test if iterator is still valid
 248                 inline bool valid() const;
 249
 250                 inline operator bool() const;
 251
 252                 // get key
 253                 inline const char* ckey() const;
 254
 255                 inline std::string key() const;
 256
 257                 // get value
 258                 inline const Value value() const;
 259
 260                 // dereference value
 261                 inline const Value operator*() const;
 262
 263         private:
 264                 // disallow copying
 265                 Iterator(const Iterator&);
 266                 Iterator& operator=(const Iterator&);
 267
 268                 // object being iterated over
 269                 Value _object;
 270
 271                 // iterator value
 272                 void* _iter;
 273         };
 274
 275         // create a new empty object
 276         inline Value object();
 277
 278         // create a new empty array
 279         inline Value array();
 280
 281         // create a new null value
 282         inline Value null();
 283
 284         // load a file as a JSON value
 285         inline Value load_file(const char* path, json_error_t* error = 0);
 286
 287         // load a string as a JSON value
 288         inline Value load_string(const char* string, json_error_t* error = 0);
 289
 290 } // namespace json
 291
 292 // stream JSON value out -- inefficient and not recommended for production use
 293 inline std::ostream& operator<<(std::ostream& os, const json::Value& value);
 294
 295 // read JSON value -- inefficient and not recommended for production use
 296 inline std::istream& operator>>(std::istream& is, json::Value& value);
 297
 298 // include implementation code
 299 #define IN_JANSSON_HPP 1
 300 #include "jansson-impl.hpp"
 301 #undef IN_JANSSON_HPP
 302
 303 #endif // defined(JANSSON_HPP)