//////////////////////////////////////////////////////////////////////////////// /// @brief json helper functions /// /// @file /// /// DISCLAIMER /// /// Copyright 2014 ArangoDB GmbH, Cologne, Germany /// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany /// /// Licensed under the Apache License, Version 2.0 (the "License"); /// you may not use this file except in compliance with the License. /// You may obtain a copy of the License at /// /// http://www.apache.org/licenses/LICENSE-2.0 /// /// Unless required by applicable law or agreed to in writing, software /// distributed under the License is distributed on an "AS IS" BASIS, /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. /// See the License for the specific language governing permissions and /// limitations under the License. /// /// Copyright holder is ArangoDB GmbH, Cologne, Germany /// /// @author Jan Steemann /// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany /// @author Copyright 2012-2013, triAGENS GmbH, Cologne, Germany //////////////////////////////////////////////////////////////////////////////// #ifndef ARANGODB_BASICS_JSON_HELPER_H #define ARANGODB_BASICS_JSON_HELPER_H 1 #include "Basics/Common.h" #include "Basics/Exceptions.h" #include "Basics/json.h" #include "Basics/StringBuffer.h" namespace triagens { namespace basics { // ----------------------------------------------------------------------------- // --SECTION-- class JsonHelper // ----------------------------------------------------------------------------- class JsonHelper { // ----------------------------------------------------------------------------- // --SECTION-- constructors / destructors // ----------------------------------------------------------------------------- private: JsonHelper () = delete; ~JsonHelper () = delete; // ----------------------------------------------------------------------------- // --SECTION-- public static methods // ----------------------------------------------------------------------------- public: //////////////////////////////////////////////////////////////////////////////// /// @brief convert a uint64 into a JSON string //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* uint64String (TRI_memory_zone_t*, uint64_t); //////////////////////////////////////////////////////////////////////////////// /// @brief convert a uint64 into a JSON string //////////////////////////////////////////////////////////////////////////////// static uint64_t stringUInt64 (TRI_json_t const*); //////////////////////////////////////////////////////////////////////////////// /// @brief convert a uint64 into a JSON string //////////////////////////////////////////////////////////////////////////////// static uint64_t stringUInt64 (TRI_json_t const*, char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a JSON object from a key/value object of strings //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* stringObject (TRI_memory_zone_t*, std::map const&); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a key/value object of strings from a JSON (sub-) object //////////////////////////////////////////////////////////////////////////////// static std::map stringObject (TRI_json_t const*); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a JSON object from an array of strings //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* stringArray (TRI_memory_zone_t*, std::vector const&); //////////////////////////////////////////////////////////////////////////////// /// @brief creates an array of strings from a JSON (sub-) object //////////////////////////////////////////////////////////////////////////////// static std::vector stringArray (TRI_json_t const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create JSON from string //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* fromString (std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief create JSON from string //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* fromString (char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create JSON from string //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* fromString (char const*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief stringify json //////////////////////////////////////////////////////////////////////////////// static std::string toString (TRI_json_t const*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns true for objects //////////////////////////////////////////////////////////////////////////////// static inline bool isObject (TRI_json_t const* json) { return json != nullptr && json->_type == TRI_JSON_OBJECT; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns true for arrays //////////////////////////////////////////////////////////////////////////////// static inline bool isArray (TRI_json_t const* json) { return json != nullptr && json->_type == TRI_JSON_ARRAY; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns true for strings //////////////////////////////////////////////////////////////////////////////// static inline bool isString (TRI_json_t const* json) { return TRI_IsStringJson(json); } //////////////////////////////////////////////////////////////////////////////// /// @brief returns true for numbers //////////////////////////////////////////////////////////////////////////////// static inline bool isNumber (TRI_json_t const* json) { return json != nullptr && json->_type == TRI_JSON_NUMBER; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns true for booleans //////////////////////////////////////////////////////////////////////////////// static inline bool isBoolean (TRI_json_t const* json) { return json != nullptr && json->_type == TRI_JSON_BOOLEAN; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns an object sub-element //////////////////////////////////////////////////////////////////////////////// static TRI_json_t* getObjectElement (TRI_json_t const*, char const* name); //////////////////////////////////////////////////////////////////////////////// /// @brief returns a string element, or a default it is does not exist //////////////////////////////////////////////////////////////////////////////// static std::string getStringValue (TRI_json_t const*, std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief returns a string sub-element, or a default it is does not exist //////////////////////////////////////////////////////////////////////////////// static std::string getStringValue (TRI_json_t const*, char const*, std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief returns a numeric value //////////////////////////////////////////////////////////////////////////////// template static T getNumericValue (TRI_json_t const* json, T defaultValue) { if (isNumber(json)) { return (T) json->_value._number; } return defaultValue; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns a numeric sub-element, or a default it is does not exist //////////////////////////////////////////////////////////////////////////////// template static T getNumericValue (TRI_json_t const* json, char const* name, T defaultValue) { TRI_json_t const* sub = getObjectElement(json, name); if (isNumber(sub)) { return (T) sub->_value._number; } return defaultValue; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns a boolean sub-element, or a default it is does not exist //////////////////////////////////////////////////////////////////////////////// static bool getBooleanValue (TRI_json_t const*, char const*, bool); //////////////////////////////////////////////////////////////////////////////// /// @brief returns a boolean sub-element, or a throws an exception if the /// sub-element does not exist or if it is not boolean //////////////////////////////////////////////////////////////////////////////// static bool checkAndGetBooleanValue (TRI_json_t const*, char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns a numeric sub-element, or throws if does not exist /// or it is not a number //////////////////////////////////////////////////////////////////////////////// template static T checkAndGetNumericValue (TRI_json_t const* json, char const* name) { TRI_json_t const* sub = getObjectElement(json, name); if (! isNumber(sub)) { std::string msg = "The attribute '" + std::string(name) + "' was not found or is not a number."; THROW_ARANGO_EXCEPTION(TRI_ERROR_INTERNAL); } return static_cast(sub->_value._number); } //////////////////////////////////////////////////////////////////////////////// /// @brief returns a string sub-element, or throws if does not exist /// or it is not a string //////////////////////////////////////////////////////////////////////////////// static std::string checkAndGetStringValue (TRI_json_t const*, char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns an object sub-element, or a throws an exception if the /// sub-element does not exist or if it is not an object //////////////////////////////////////////////////////////////////////////////// static TRI_json_t const* checkAndGetObjectValue (TRI_json_t const*, char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns an array sub-element, or a throws an exception if the /// sub-element does not exist or if it is not an array //////////////////////////////////////////////////////////////////////////////// static TRI_json_t const* checkAndGetArrayValue (TRI_json_t const*, char const*); }; //////////////////////////////////////////////////////////////////////////////// /// @brief JsonException, an exception class for the Json class //////////////////////////////////////////////////////////////////////////////// class JsonException : public virtual std::exception { std::string _msg; public: JsonException () : _msg("Json exception") { #ifdef TRI_ENABLE_MAINTAINER_MODE #if HAVE_BACKTRACE _msg += std::string("\n\n"); TRI_GetBacktrace(_msg); _msg += std::string("\n\n"); #endif #endif } JsonException (std::string msg) : _msg(msg) { #ifdef TRI_ENABLE_MAINTAINER_MODE #if HAVE_BACKTRACE _msg += std::string("\n\n"); TRI_GetBacktrace(_msg); _msg += std::string("\n\n"); #endif #endif } char const* what () const throw() { return _msg.c_str(); } }; //////////////////////////////////////////////////////////////////////////////// /// @brief Json, a class to fabricate TRI_json_t* conveniently //////////////////////////////////////////////////////////////////////////////// class Json { public: //////////////////////////////////////////////////////////////////////////////// /// @brief enum for the type of a Json structure //////////////////////////////////////////////////////////////////////////////// enum type_e { Null, Bool, Number, String, Array, Object }; //////////////////////////////////////////////////////////////////////////////// /// @brief enum to say whether we are automatically freeing the TRI_json_t* //////////////////////////////////////////////////////////////////////////////// enum autofree_e { AUTOFREE, NOFREE }; // ----------------------------------------------------------------------------- // --SECTION-- private methods // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief internal helper for the generic constructor //////////////////////////////////////////////////////////////////////////////// void make (type_e t, size_t sizeHint) { // convert to an actual memory zone TRI_memory_zone_t* zone = TRI_MemoryZone(_zone); switch (t) { case Null: _json = TRI_CreateNullJson(zone); break; case Bool: _json = TRI_CreateBooleanJson(zone, true); break; case Number: _json = TRI_CreateNumberJson(zone, 0.0); break; case String: _json = TRI_CreateStringCopyJson(zone, "", 0); break; case Array: _json = TRI_CreateArrayJson(zone, sizeHint); break; case Object: _json = TRI_CreateObjectJson(zone, 2 * sizeHint); break; } if (_json == nullptr) { throw JsonException("Json: out of memory"); } } // ----------------------------------------------------------------------------- // --SECTION-- public constructors // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief default constructor making an empty Json //////////////////////////////////////////////////////////////////////////////// public: explicit Json () : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(AUTOFREE) { } //////////////////////////////////////////////////////////////////////////////// /// @brief generic constructor for a type_e //////////////////////////////////////////////////////////////////////////////// explicit Json (type_e t, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { make(t, 0); } //////////////////////////////////////////////////////////////////////////////// /// @brief generic constructor for a memzone and a type_e //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, type_e t, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { make(t, 0); } //////////////////////////////////////////////////////////////////////////////// /// @brief generic constructor for a type_e with a size hint //////////////////////////////////////////////////////////////////////////////// explicit Json (type_e t, size_t sizeHint, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { make(t, sizeHint); } //////////////////////////////////////////////////////////////////////////////// /// @brief generic constructor for a memzone, a type_e and a size hint //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, type_e t, size_t sizeHint, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { make(t, sizeHint); } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a bool //////////////////////////////////////////////////////////////////////////////// explicit Json (bool x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { _json = TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, x); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a bool //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, bool x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { _json = TRI_CreateBooleanJson(z, x); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for an int32_t //////////////////////////////////////////////////////////////////////////////// explicit Json (int32_t x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { _json = TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, static_cast(x)); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and an int32_t //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, int32_t x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { _json = TRI_CreateNumberJson(z, static_cast(x)); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a double //////////////////////////////////////////////////////////////////////////////// explicit Json (double x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { _json = TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, x); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a double //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, double x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { _json = TRI_CreateNumberJson(z, x); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a char const* //////////////////////////////////////////////////////////////////////////////// explicit Json (char const* x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { _json = TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, x, strlen(x)); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a char const* //////////////////////////////////////////////////////////////////////////////// explicit Json (char const* x, size_t length, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { _json = TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, x, length); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a char const* //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, char const* x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { _json = TRI_CreateStringCopyJson(z, x, strlen(x)); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a char const* //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, char const* x, size_t length, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { _json = TRI_CreateStringCopyJson(z, x, length); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a string //////////////////////////////////////////////////////////////////////////////// explicit Json (std::string const& x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(TRI_UNKNOWN_MEM_ZONE)), _autofree(autofree) { _json = TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, x.c_str(), x.size()); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a string //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, std::string const& x, autofree_e autofree = AUTOFREE) : _json(nullptr), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { _json = TRI_CreateStringCopyJson(z, x.c_str(), x.size()); if (_json == nullptr) { throw JsonException("Json: out of memory"); } } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a TRI_json_t* //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, TRI_json_t* j, autofree_e autofree = AUTOFREE) : _json(j), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a memzone and a const TRI_json_t* //////////////////////////////////////////////////////////////////////////////// explicit Json (TRI_memory_zone_t* z, TRI_json_t const* j, autofree_e autofree = NOFREE) : _json(const_cast(j)), _zone(TRI_MemoryZoneId(z)), _autofree(autofree) { } explicit Json (TRI_json_t* j) = delete; explicit Json (TRI_json_t const *) = delete; //////////////////////////////////////////////////////////////////////////////// /// @brief "copy" constructor, note that in the AUTOFREE case this steals /// the structure from j to allow returning Json objects by value without /// copying the whole structure. //////////////////////////////////////////////////////////////////////////////// Json (Json& j) : _json(j.steal()), _zone(j._zone), _autofree(j._autofree) { } //////////////////////////////////////////////////////////////////////////////// /// @brief move constructor, note that in the AUTOFREE case this steals /// the structure from j to allow returning Json objects by value without /// copying the whole structure. //////////////////////////////////////////////////////////////////////////////// Json (Json&& j) : _json(j.steal()), _zone(j._zone), _autofree(j._autofree) { } //////////////////////////////////////////////////////////////////////////////// /// @brief delete the normal move constructor, because we do not want /// invisible recursive copies to be taken of TRI_json_t* managed by this /// Json class. Also, we do not want a const copy constructor stealing /// the reference. //////////////////////////////////////////////////////////////////////////////// Json (Json const&&) = delete; //////////////////////////////////////////////////////////////////////////////// /// @brief destructor //////////////////////////////////////////////////////////////////////////////// ~Json () throw() { if (_json != nullptr && _autofree == AUTOFREE) { TRI_FreeJson(TRI_MemoryZone(_zone), _json); } } // ----------------------------------------------------------------------------- // --SECTION-- public methods // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief return internal TRI_json_t*, this does not change the ownership /// of the pointer //////////////////////////////////////////////////////////////////////////////// TRI_json_t* json () const throw() { return _json; } //////////////////////////////////////////////////////////////////////////////// /// @brief steal the TRI_json_t*, that is, in the AUTOFREE case the pointer /// _json is changed to a nullptr. This is used in the copy and the move /// constructor and in the cast operator to TRI_json_t*. //////////////////////////////////////////////////////////////////////////////// TRI_json_t* steal () throw() { TRI_json_t* res = _json; if (_autofree == AUTOFREE) { _json = nullptr; } return res; } //////////////////////////////////////////////////////////////////////////////// /// @brief assignment operator, note that, as the copy constructor, this /// has steal semantics, which avoids deep copies in situations that /// people will use. If you need an actual copy, use the copy method. //////////////////////////////////////////////////////////////////////////////// Json& operator= (Json& j) { if (_json != nullptr && _autofree == AUTOFREE) { TRI_FreeJson(TRI_MemoryZone(_zone), _json); } _zone = j._zone; _autofree = j._autofree; _json = j.steal(); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief move assignment operator, this has steal semantics. //////////////////////////////////////////////////////////////////////////////// Json& operator= (Json&& j) { if (_json != nullptr && _autofree == AUTOFREE) { TRI_FreeJson(TRI_MemoryZone(_zone), _json); } _zone = j._zone; _autofree = j._autofree; _json = j.steal(); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief copy recursively, even if NOFREE is set! Note that the copy is // AUTOFREE //////////////////////////////////////////////////////////////////////////////// Json copy (autofree_e autofree = AUTOFREE) const { Json c; c._zone = _zone; if (_json != nullptr) { c._json = TRI_CopyJson(TRI_MemoryZone(_zone), _json); } else { c._json = nullptr; } c._autofree = autofree; return c; } //////////////////////////////////////////////////////////////////////////////// /// @brief set an attribute value in an array, an exception is thrown /// if *this is not a Json object. The pointer managed by sub is /// stolen. The purpose of this method is that you can do /// Json(Json::Object).set("a",Json(12)).set("b",Json(true)) /// and that this is both legal and efficient. //////////////////////////////////////////////////////////////////////////////// Json& set (char const* name, Json sub) { if (! TRI_IsObjectJson(_json)) { throw JsonException("Json is no object"); } TRI_Insert3ObjectJson(TRI_MemoryZone(_zone), _json, name, sub.steal()); return *this; } Json& set (std::string const& name, Json sub) { if (! TRI_IsObjectJson(_json)) { throw JsonException("Json is no object"); } TRI_Insert3ObjectJson(TRI_MemoryZone(_zone), _json, name.c_str(), sub.steal()); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief set an attribute value in an object, an exception is thrown if /// *this is not a Json object. The pointer sub is integrated into the /// object and will be freed if and only if the main thing is freed. //////////////////////////////////////////////////////////////////////////////// Json& set (char const* name, TRI_json_t* sub) { if (! TRI_IsObjectJson(_json)) { throw JsonException("Json is no object"); } TRI_Insert3ObjectJson(TRI_MemoryZone(_zone), _json, name, sub); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief this gets an attribute value of a Json object. An exception is /// thrown if *this is not a Json object. The resulting TRI_json_t* is /// wrapped in a NOFREE Json to allow things like /// j.get("a").get("b") /// to access j.a.b. The ownership of the whole structure remains with /// *this. //////////////////////////////////////////////////////////////////////////////// Json get (char const* name) const { if (! TRI_IsObjectJson(_json)) { throw JsonException("Json is no object"); } return Json(TRI_MemoryZone(_zone), TRI_LookupObjectJson(_json, name), NOFREE); } //////////////////////////////////////////////////////////////////////////////// /// @brief this is a syntactic shortcut for the set method using operator() //////////////////////////////////////////////////////////////////////////////// Json& operator() (char const* name, Json sub) { return set(name, sub); } //////////////////////////////////////////////////////////////////////////////// /// @brief this is a syntactic shortcut for the set method using operator() //////////////////////////////////////////////////////////////////////////////// Json& operator() (char const* name, TRI_json_t* sub) { return set(name, sub); } //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the JSON object has a specific attribute //////////////////////////////////////////////////////////////////////////////// bool has (char const* name) const { if (! TRI_IsObjectJson(_json)) { throw JsonException("Json is no object"); } return (TRI_LookupObjectJson(_json, name) != nullptr); } //////////////////////////////////////////////////////////////////////////////// /// @brief append a Json value to the end of a Json array, an exception /// is thrown if *this is not a Json array. The pointer managed by sub is /// stolen. The purpose of this method is that you can do /// Json(Json::Array).add(Json(12)).add(Json(13)) /// and that this is both legal and efficient. //////////////////////////////////////////////////////////////////////////////// Json& add (Json sub) { if (! TRI_IsArrayJson(_json)) { throw JsonException("Json is no array"); } TRI_PushBack3ArrayJson(TRI_MemoryZone(_zone), _json, sub.steal()); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief append a TRI_json_t value to the end of a Json array, an exception /// is thrown if *this is not a Json array. The pointer sub is integrated /// into the array and will be freed if and only if the main thing is /// freed. //////////////////////////////////////////////////////////////////////////////// Json& add (TRI_json_t* sub) { if (! TRI_IsArrayJson(_json)) { throw JsonException("Json is no array"); } TRI_PushBack3ArrayJson(TRI_MemoryZone(_zone), _json, sub); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief append a Json value to the end of a Json array, an exception /// is thrown if *this is not a Json array. The data pointed to by the source /// json pointer is copied into the result, and the original data is nullified /// (so it can be destroyed safely later by its original possessor). //////////////////////////////////////////////////////////////////////////////// Json& transfer (TRI_json_t* json) { if (! TRI_IsArrayJson(_json)) { throw JsonException("Json is no array"); } TRI_PushBack2ArrayJson(_json, json); TRI_InitNullJson(json); return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief reserve space for n additional items in an array //////////////////////////////////////////////////////////////////////////////// Json& reserve (size_t n) { if (! TRI_IsArrayJson(_json)) { throw JsonException("Json is no array"); } if (TRI_ReserveVector(&_json->_value._objects, n) != TRI_ERROR_NO_ERROR) { throw JsonException("Json: out of memory"); } return *this; } //////////////////////////////////////////////////////////////////////////////// /// @brief this is a syntactic shortcut for the add method using operator() //////////////////////////////////////////////////////////////////////////////// Json& operator() (Json sub) { return add(sub); } //////////////////////////////////////////////////////////////////////////////// /// @brief this is a syntactic shortcut for the add method using operator() //////////////////////////////////////////////////////////////////////////////// Json& operator() (TRI_json_t* sub) { return add(sub); } //////////////////////////////////////////////////////////////////////////////// /// @brief this gets an array entry of a Json array. An exception is /// thrown if *this is not a Json array. The resulting TRI_json_t* is /// wrapped in a NOFREE Json to allow things like /// j.at(0).at(1) /// to access j[0][1]. The ownership of the whole structure remains with /// *this. If the position given is not bound, then an empty Json is /// returned. //////////////////////////////////////////////////////////////////////////////// Json at (size_t pos) const { return at(static_cast(pos)); } Json at (int pos) const { if (! TRI_IsArrayJson(_json)) { throw JsonException("Json is no array"); } TRI_json_t* j; if (pos >= 0) { j = TRI_LookupArrayJson(_json, pos); if (j != nullptr) { return Json(TRI_MemoryZone(_zone), j, NOFREE); } else { return Json(TRI_MemoryZone(_zone), Json::Null, AUTOFREE); } } else { size_t pos2 = -pos; size_t len = TRI_LengthVector(&_json->_value._objects); if (pos2 > len) { return Json(TRI_MemoryZone(_zone), Json::Null, AUTOFREE); } j = TRI_LookupArrayJson(_json, len-pos2); if (j != nullptr) { return Json(TRI_MemoryZone(_zone), j, NOFREE); } else { return Json(TRI_MemoryZone(_zone), Json::Null, AUTOFREE); } } } //////////////////////////////////////////////////////////////////////////////// /// @brief destroy the contents of the JSON //////////////////////////////////////////////////////////////////////////////// void destroy () { if (_json != nullptr) { TRI_FreeJson(TRI_MemoryZone(_zone), _json); _json = nullptr; } } //////////////////////////////////////////////////////////////////////////////// /// @brief return the JSON's memory zone //////////////////////////////////////////////////////////////////////////////// TRI_memory_zone_t* zone () const { return TRI_MemoryZone(_zone); } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is a Json that is equal to null. //////////////////////////////////////////////////////////////////////////////// bool isNull () const throw() { return _json != nullptr && _json->_type == TRI_JSON_NULL; } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is a boolean Json. //////////////////////////////////////////////////////////////////////////////// bool isBoolean () const throw() { return TRI_IsBooleanJson(_json); } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is a number Json. //////////////////////////////////////////////////////////////////////////////// bool isNumber () const throw() { return TRI_IsNumberJson(_json); } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is a string Json. //////////////////////////////////////////////////////////////////////////////// bool isString () const throw() { return TRI_IsStringJson(_json); } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is an object Json. //////////////////////////////////////////////////////////////////////////////// bool isObject () const throw() { return TRI_IsObjectJson(_json); } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is an array Json. //////////////////////////////////////////////////////////////////////////////// bool isArray () const throw() { return TRI_IsArrayJson(_json); } //////////////////////////////////////////////////////////////////////////////// /// @brief returns the length of the array //////////////////////////////////////////////////////////////////////////////// size_t size () const { if (! TRI_IsArrayJson(_json)) { throw JsonException("Json is no array"); } return TRI_LengthVector(&_json->_value._objects); } //////////////////////////////////////////////////////////////////////////////// /// @brief returns the length of the array //////////////////////////////////////////////////////////////////////////////// size_t members () const { if (! TRI_IsObjectJson(_json)) { throw JsonException("Json is no object"); } return TRI_LengthVector(&_json->_value._objects) / 2; } //////////////////////////////////////////////////////////////////////////////// /// @brief checks whether *this is an empty Json (not even null). //////////////////////////////////////////////////////////////////////////////// bool isEmpty () const throw() { return _json == nullptr; } //////////////////////////////////////////////////////////////////////////////// /// @brief converts the Json recursively into a string. //////////////////////////////////////////////////////////////////////////////// std::string toString () const { if (_json != nullptr) { return JsonHelper::toString(_json); } return std::string(""); } //////////////////////////////////////////////////////////////////////////////// /// @brief appends JSON to a string buffer //////////////////////////////////////////////////////////////////////////////// void dump (triagens::basics::StringBuffer& buffer) const { if (_json != nullptr) { int res = TRI_StringifyJson(buffer.stringBuffer(), _json); if (res != TRI_ERROR_NO_ERROR) { throw JsonException("Json: out of memory"); } } } friend std::ostream& operator<< (std::ostream&, Json const*); friend std::ostream& operator<< (std::ostream&, Json const&); // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief the actual TRI_json_t* //////////////////////////////////////////////////////////////////////////////// TRI_json_t* _json; //////////////////////////////////////////////////////////////////////////////// /// @brief the memory zone used //////////////////////////////////////////////////////////////////////////////// TRI_memory_zone_id_t _zone; //////////////////////////////////////////////////////////////////////////////// /// @brief flag, whether we automatically free the TRI_json_t*. //////////////////////////////////////////////////////////////////////////////// autofree_e _autofree; }; } } #endif // ----------------------------------------------------------------------------- // --SECTION-- END-OF-FILE // ----------------------------------------------------------------------------- // Local Variables: // mode: outline-minor // outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}" // End: