src/jansson-impl.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(IN_JANSSON_HPP)
   7 #error "jansson-impl.hpp may only by included from jansson.hpp"
   8 #endif
   9
  10 namespace json {
  11     namespace _private {
  12         // assignment operator
  13         template <typename _Base>
  14         ValueBase<_Base>& ValueBase<_Base>::operator=(const Value& value) {
  15             _Base::operator=(value);
  16             return *this;
  17         }
  18
  19         // check value type
  20         template <typename _Base>
  21         bool ValueBase<_Base>::is_undefined() const {
  22             return _Base::as_json() == 0;
  23         }
  24
  25         template <typename _Base>
  26         bool ValueBase<_Base>::is_object() const {
  27             return json_is_object(_Base::as_json());
  28         }
  29
  30         template <typename _Base>
  31         bool ValueBase<_Base>::is_array() const {
  32             return json_is_array(_Base::as_json());
  33         }
  34
  35         template <typename _Base>
  36         bool ValueBase<_Base>::is_string() const {
  37             return json_is_string(_Base::as_json());
  38         }
  39
  40         template <typename _Base>
  41         bool ValueBase<_Base>::is_integer() const {
  42             return json_is_integer(_Base::as_json());
  43         }
  44
  45         template <typename _Base>
  46         bool ValueBase<_Base>::is_real() const {
  47             return json_is_real(_Base::as_json());
  48         }
  49
  50         template <typename _Base>
  51         bool ValueBase<_Base>::is_number() const {
  52             return json_is_number(_Base::as_json());
  53         }
  54
  55         template <typename _Base>
  56         bool ValueBase<_Base>::is_true() const {
  57             return json_is_true(_Base::as_json());
  58         }
  59
  60         template <typename _Base>
  61         bool ValueBase<_Base>::is_false() const {
  62             return json_is_false(_Base::as_json());
  63         }
  64
  65         template <typename _Base>
  66         bool ValueBase<_Base>::is_boolean() const {
  67             return json_is_boolean(_Base::as_json());
  68         }
  69
  70         template <typename _Base>
  71         bool ValueBase<_Base>::is_null() const {
  72             return json_is_null(_Base::as_json());
  73         }
  74
  75         // get size of array or object
  76         template <typename _Base>
  77         unsigned int ValueBase<_Base>::size() const {
  78             if (is_object())
  79                 return json_object_size(_Base::as_json());
  80             else
  81                 return json_array_size(_Base::as_json());
  82         }
  83
  84         // get value at array index (const version)
  85         template <typename _Base>
  86         const Value ValueBase<_Base>::at(unsigned int index) const {
  87             return Value(json_array_get(_Base::as_json(), index));
  88         }
  89
  90         template <typename _Base>
  91         const Value ValueBase<_Base>::operator[](signed int index) const { return at(index); }
  92         template <typename _Base>
  93         const Value ValueBase<_Base>::operator[](unsigned int index) const { return at(index); }
  94         template <typename _Base>
  95         const Value ValueBase<_Base>::operator[](signed short index) const { return at(index); }
  96         template <typename _Base>
  97         const Value ValueBase<_Base>::operator[](unsigned short index) const { return at(index); }
  98         template <typename _Base>
  99         const Value ValueBase<_Base>::operator[](signed long index) const { return at(index); }
 100         template <typename _Base>
 101         const Value ValueBase<_Base>::operator[](unsigned long index) const { return at(index); }
 102
 103         // get value at array index (non-const version)
 104         template <typename _Base>
 105         ValueBase<ElementProxy> ValueBase<_Base>::at(unsigned int index) {
 106             return ElementProxy(_Base::as_json(), index);
 107         }
 108
 109         template <typename _Base>
 110         ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed int index) {
 111             return at(index);
 112         }
 113
 114         template <typename _Base>
 115         ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned int index) {
 116             return at(index);
 117         }
 118
 119         template <typename _Base>
 120         ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed short index) {
 121             return at(index);
 122         }
 123
 124         template <typename _Base>
 125         ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned short index) {
 126             return at(index);
 127         }
 128
 129         template <typename _Base>
 130         ValueBase<ElementProxy> ValueBase<_Base>::operator[](signed long index) {
 131             return at(index);
 132         }
 133
 134         template <typename _Base>
 135         ValueBase<ElementProxy> ValueBase<_Base>::operator[](unsigned long index) {
 136             return at(index);
 137         }
 138
 139         // get object property (const version)
 140         template <typename _Base>
 141         const Value ValueBase<_Base>::get(const char* key) const {
 142             return Value(json_object_get(_Base::as_json(), key));
 143         }
 144
 145         template <typename _Base>
 146         const Value ValueBase<_Base>::get(const std::string& key) const {
 147             return get(key.c_str());
 148         }
 149
 150         template <typename _Base>
 151         const Value ValueBase<_Base>::operator[](const char* key) const {
 152             return get(key);
 153         }
 154
 155         template <typename _Base>
 156         const Value ValueBase<_Base>::operator[](const std::string& key) const {
 157             return get(key.c_str());
 158         }
 159
 160         // get object property (non-const version)
 161         template <typename _Base>
 162         ValueBase<PropertyProxy> ValueBase<_Base>::get(const char* key) {
 163             return PropertyProxy(_Base::as_json(), key);
 164         }
 165
 166         template <typename _Base>
 167         ValueBase<PropertyProxy> ValueBase<_Base>::get(const std::string& key) {
 168             return get(key.c_str());
 169         }
 170
 171         template <typename _Base>
 172         ValueBase<PropertyProxy> ValueBase<_Base>::operator[](const char* key) {
 173             return get(key);
 174         }
 175
 176         template <typename _Base>
 177         ValueBase<PropertyProxy> ValueBase<_Base>::operator[](const std::string& key) {
 178             return get(key.c_str());
 179         }
 180
 181         // clear all array/object values
 182         template <typename _Base>
 183         void ValueBase<_Base>::clear() {
 184             if (is_object())
 185                 json_object_clear(_Base::as_json());
 186             else
 187                 json_array_clear(_Base::as_json());
 188         }
 189
 190         // get value cast to specified type
 191         template <typename _Base>
 192         const char* ValueBase<_Base>::as_cstring() const {
 193             return json_string_value(_Base::as_json());
 194         }
 195
 196         template <typename _Base>
 197         std::string ValueBase<_Base>::as_string() const {
 198             const char* tmp = as_cstring();
 199             return tmp == 0 ? "" : tmp;
 200         }
 201
 202         template <typename _Base>
 203         int ValueBase<_Base>::as_integer() const {
 204             return json_integer_value(_Base::as_json());
 205         }
 206
 207         template <typename _Base>
 208         double ValueBase<_Base>::as_real() const {
 209             return json_real_value(_Base::as_json());
 210         }
 211
 212         template <typename _Base>
 213         double ValueBase<_Base>::as_number() const {
 214             return json_number_value(_Base::as_json());
 215         }
 216
 217         template <typename _Base>
 218         bool ValueBase<_Base>::as_boolean() const {
 219             return is_true();
 220         }
 221
 222         // set an object property (converts value to object is not one already)
 223         template <typename _Base>
 224         _Base& ValueBase<_Base>::set_key(const char* key, const Value& value) {
 225             json_object_set(_Base::as_json(), key, value._Base::as_json());
 226             return *this;
 227         }
 228
 229         template <typename _Base>
 230         _Base& ValueBase<_Base>::set_key(const std::string& key, const Value& value) {
 231             return set_key(key.c_str(), value);
 232         }
 233
 234         // set an array index (converts value to object is not one already)
 235         template <typename _Base>
 236         _Base& ValueBase<_Base>::set_at(unsigned int index, const Value& value) {
 237             if (index == size())
 238                 json_array_append(_Base::as_json(), value._Base::as_json());
 239             else
 240                 json_array_set(_Base::as_json(), index, value._Base::as_json());
 241             return *this;
 242         }
 243
 244         // delete an object key
 245         template <typename _Base>
 246         _Base& ValueBase<_Base>::del_key(const char* key) {
 247             json_object_del(_Base::as_json(), key);
 248             return *this;
 249         }
 250
 251         template <typename _Base>
 252         _Base& ValueBase<_Base>::del_key(const std::string& key) {
 253             return del_key(key.c_str());
 254         }
 255
 256         // delete an item from an array by index
 257         template <typename _Base>
 258         _Base& ValueBase<_Base>::del_at(unsigned int index) {
 259             json_array_remove(_Base::as_json(), index);
 260             return *this;
 261         }
 262
 263         // insert an item into an array at a given index
 264         template <typename _Base>
 265         _Base& ValueBase<_Base>::insert_at(unsigned int index, const Value& value) {
 266             json_array_insert(_Base::as_json(), index, value._Base::as_json());
 267             return *this;
 268         }
 269
 270         // write the value to a file
 271         template <typename _Base>
 272         int ValueBase<_Base>::save_file(const char* path, int flags) const {
 273             return json_dump_file(_Base::as_json(), path, flags);
 274         }
 275
 276         // write the value to a string (caller must deallocate with free()!)
 277         template <typename _Base>
 278         char* ValueBase<_Base>::save_string(int flags) const {
 279             return json_dumps(_Base::as_json(), flags);
 280         }
 281
 282         Basic::~Basic() {
 283             json_decref(_value);
 284         }
 285
 286         // copy an existing Value
 287         Basic& Basic::operator=(const Basic& e) {
 288             if (&e != this) {
 289                 json_decref(_value);
 290                 _value = json_incref(e._value);
 291             }
 292             return *this;
 293         }
 294
 295         // get the underlying json_t
 296         json_t* Basic::as_json() const {
 297             return _value;
 298         }
 299
 300         // take ownership of a json_t (does not increase reference count)
 301         Basic Basic::take_ownership(json_t* json) {
 302             Basic v;
 303             v._value = json;
 304             return v;
 305         }
 306
 307         // assign value to proxied array element
 308         ElementProxy& ElementProxy::operator=(const Value& value) {
 309             json_array_set(_array, _index, value.as_json());
 310             return *this;
 311         }
 312
 313         // get the proxied element
 314         json_t* ElementProxy::as_json() const {
 315             return json_array_get(_array, _index);
 316         }
 317
 318         // assign value to proxied object property
 319         PropertyProxy& PropertyProxy::operator=(const Value& value) {
 320             json_object_set(_object, _key, value.as_json());
 321             return *this;
 322         }
 323
 324         json_t* PropertyProxy::as_json() const {
 325             return json_object_get(_object, _key);
 326         }
 327
 328     } // namespace json::_private
 329
 330     // construct Value::Value input
 331     Value::Value(const char* value) {
 332         _value = json_string(value);
 333     }
 334
 335     Value::Value(const std::string& value) {
 336         _value = json_string(value.c_str());
 337     }
 338
 339     Value::Value(bool value) {
 340         _value = value ? json_true() : json_false();
 341     }
 342
 343     Value::Value(signed int value) {
 344         _value = json_integer(value);
 345     }
 346
 347     Value::Value(unsigned int value) {
 348         _value = json_integer(value);
 349     }
 350
 351     Value::Value(signed short value) {
 352         _value = json_integer(value);
 353     }
 354
 355     Value::Value(unsigned short value) {
 356         _value = json_integer(value);
 357     }
 358
 359     Value::Value(signed long value) {
 360         _value = json_integer(value);
 361     }
 362
 363     Value::Value(unsigned long value) {
 364         _value = json_integer(value);
 365     }
 366
 367     Value::Value(float value) {
 368         _value = json_real(value);
 369     }
 370
 371     Value::Value(double value) {
 372         _value = json_real(value);
 373     }
 374
 375     // construct a new iterator for a given object
 376     Iterator::Iterator(const Value& value) : _object(value), _iter(0) {
 377         _iter = json_object_iter(_object.as_json());
 378     }
 379
 380     // construct a new iterator for a given object
 381     Iterator::Iterator(const _private::ValueBase<_private::PropertyProxy>& value) :
 382         _object(value.as_json()), _iter(0) {
 383         _iter = json_object_iter(_object.as_json());
 384     }
 385
 386     // increment iterator
 387     void Iterator::next() {
 388         _iter = json_object_iter_next(_object.as_json(), _iter);
 389     }
 390
 391     Iterator& Iterator::operator++() { next(); return *this; }
 392
 393     // test if iterator is still valid
 394     bool Iterator::valid() const {
 395         return _iter != 0;
 396     }
 397
 398     Iterator::operator bool() const {
 399         return valid();
 400     }
 401
 402     // get key
 403     const char* Iterator::ckey() const {
 404         return json_object_iter_key(_iter);
 405     }
 406
 407     std::string Iterator::key() const {
 408         return ckey();
 409     }
 410
 411     // get value
 412     const Value Iterator::value() const {
 413         return Value(json_object_iter_value(_iter));
 414     }
 415
 416     // dereference value
 417     const Value Iterator::operator*() const {
 418         return value();
 419     }
 420
 421     // create a new empty object
 422     Value object() {
 423         return Value::take_ownership(json_object());
 424     }
 425
 426     // create a new empty array
 427     Value array() {
 428         return Value::take_ownership(json_array());
 429     }
 430
 431     // create a new null value
 432     Value null() {
 433         return Value::take_ownership(json_null());
 434     }
 435
 436     // load a file as a JSON value
 437     Value load_file(const char* path, json_error_t* error) {
 438         return Value::take_ownership(json_load_file(path, error));
 439     }
 440
 441     // load a string as a JSON value
 442     Value load_string(const char* string, json_error_t* error) {
 443         return Value::take_ownership(json_loads(string, error));
 444     }
 445
 446 } // namespace json
 447
 448 // stream JSON value out
 449 std::ostream& operator<<(std::ostream& os, const json::Value& value) {
 450     // get the temporary serialize string
 451     char* tmp = value.save_string();
 452     if (tmp != 0) {
 453         // stream temp string out and release it
 454         os << tmp;
 455         free(tmp);
 456     }
 457     return os;
 458 }
 459
 460 // read JSON value
 461 std::istream& operator>>(std::istream& is, json::Value& value) {
 462     // buffer the remaining bytes into a single string for Jansson
 463     std::stringstream tmp;
 464     while (is)
 465         tmp << static_cast<char>(is.get());
 466     // parse the buffered string
 467     value = json::load_string(tmp.str().c_str());
 468     return is;
 469 }