From a08a4eb5effade211222618a0164813720b860e9 Mon Sep 17 00:00:00 2001 From: Magne Sjaastad Date: Thu, 2 Jun 2016 11:31:41 +0200 Subject: [PATCH] Added custom wrapper for json files to control install features of json --- ApplicationCode/CMakeLists.txt | 4 +- CMakeLists.txt | 6 +- ThirdParty/custom-opmjson/CMakeLists.txt | 18 + .../custom-opmjson/opm/json/CMakeLists.txt | 23 + .../custom-opmjson/opm/json/JsonObject.cpp | 206 +++++++ .../custom-opmjson/opm/json/JsonObject.hpp | 74 +++ .../custom-opmjson/opm/json/cjson/README | 247 ++++++++ .../custom-opmjson/opm/json/cjson/README.opm | 4 + .../custom-opmjson/opm/json/cjson/cJSON.c | 569 ++++++++++++++++++ .../custom-opmjson/opm/json/cjson/cJSON.h | 143 +++++ .../opm/json/tests/CMakeLists.txt | 5 + .../opm/json/tests/jsonTests.cpp | 281 +++++++++ 12 files changed, 1575 insertions(+), 5 deletions(-) create mode 100644 ThirdParty/custom-opmjson/CMakeLists.txt create mode 100644 ThirdParty/custom-opmjson/opm/json/CMakeLists.txt create mode 100644 ThirdParty/custom-opmjson/opm/json/JsonObject.cpp create mode 100644 ThirdParty/custom-opmjson/opm/json/JsonObject.hpp create mode 100644 ThirdParty/custom-opmjson/opm/json/cjson/README create mode 100644 ThirdParty/custom-opmjson/opm/json/cjson/README.opm create mode 100644 ThirdParty/custom-opmjson/opm/json/cjson/cJSON.c create mode 100644 ThirdParty/custom-opmjson/opm/json/cjson/cJSON.h create mode 100644 ThirdParty/custom-opmjson/opm/json/tests/CMakeLists.txt create mode 100644 ThirdParty/custom-opmjson/opm/json/tests/jsonTests.cpp diff --git a/ApplicationCode/CMakeLists.txt b/ApplicationCode/CMakeLists.txt index 27ee5781e2..bab960e65f 100644 --- a/ApplicationCode/CMakeLists.txt +++ b/ApplicationCode/CMakeLists.txt @@ -365,6 +365,8 @@ if (MSVC) optimized ${Boost_SYSTEM_LIBRARY_RELEASE} debug ${Boost_FILESYSTEM_LIBRARY_DEBUG} optimized ${Boost_FILESYSTEM_LIBRARY_RELEASE} + debug ${Boost_REGEX_LIBRARY_DEBUG} + optimized ${Boost_REGEX_LIBRARY_RELEASE} ) else() set (RI_BOOST_LIBRARIES ${Boost_LIBRARIES}) @@ -383,7 +385,7 @@ set( LINK_LIBRARIES custom-opm-common custom-opm-parser - opmjson + custom-opmjson NRLib diff --git a/CMakeLists.txt b/CMakeLists.txt index 41722553ae..ee7aaa8cc1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -154,14 +154,12 @@ endif(RESINSIGHT_ERT_EXTERNAL_LIB_ROOT OR RESINSIGHT_ERT_EXTERNAL_INCLUDE_ROOT) add_subdirectory(ThirdParty/custom-opm-common) add_subdirectory(ThirdParty/custom-opm-parser) - -include_directories(${custom-opm-parser_SOURCE_DIR}/opm-parser/) -add_subdirectory(ThirdParty/custom-opm-parser/opm-parser/opm/json) +add_subdirectory(ThirdParty/custom-opmjson) set_property(TARGET custom-opm-common custom-opm-parser - opmjson + custom-opmjson PROPERTY FOLDER "OPM" ) diff --git a/ThirdParty/custom-opmjson/CMakeLists.txt b/ThirdParty/custom-opmjson/CMakeLists.txt new file mode 100644 index 0000000000..bad1be1622 --- /dev/null +++ b/ThirdParty/custom-opmjson/CMakeLists.txt @@ -0,0 +1,18 @@ +cmake_minimum_required (VERSION 2.8) + +project (custom-opmjson) + +include_directories( + ${Boost_INCLUDE_DIRS} + ${CMAKE_CURRENT_SOURCE_DIR} +) + +list (APPEND MAIN_SOURCE_FILES + opm/json/JsonObject.cpp + opm/json/cjson/cJSON.c +) + +add_library( ${PROJECT_NAME} + ${MAIN_SOURCE_FILES} +) + diff --git a/ThirdParty/custom-opmjson/opm/json/CMakeLists.txt b/ThirdParty/custom-opmjson/opm/json/CMakeLists.txt new file mode 100644 index 0000000000..5f4547c9b3 --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/CMakeLists.txt @@ -0,0 +1,23 @@ +set( json_source JsonObject.cpp ) +set( json_headers JsonObject.hpp ) +if (NOT HAVE_CJSON) + list(APPEND json_source cjson/cJSON.c) + set( CJSON_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ) + set(CJSON_LIBRARY "") +endif() + +include_directories( + ${Boost_INCLUDE_DIRS} +) + +add_library(opmjson ${json_source}) +target_link_libraries( opmjson ${CJSON_LIBRARY} ${Boost_LIBRARIES} ) +#set_target_properties(opmjson PROPERTIES VERSION ${opm-parser_VERSION_MAJOR}.${opm-parser_VERSION_MINOR} +# SOVERSION ${opm-parser_VERSION_MAJOR}) + +install( TARGETS opmjson DESTINATION ${CMAKE_INSTALL_LIBDIR} ) +foreach ( header ${json_headers} ) + install( FILES ${header} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/opm/json RENAME ${header}) +endforeach() + +#add_subdirectory( tests ) diff --git a/ThirdParty/custom-opmjson/opm/json/JsonObject.cpp b/ThirdParty/custom-opmjson/opm/json/JsonObject.cpp new file mode 100644 index 0000000000..8ddc82e1e4 --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/JsonObject.cpp @@ -0,0 +1,206 @@ +/* + Copyright 2013 Statoil ASA. + + This file is part of the Open Porous Media project (OPM). + + OPM is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OPM is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OPM. If not, see . +*/ + + +#include +#include +#include +#include + +#include +#include + +#include +#include "cjson/cJSON.h" + +namespace Json { + + void JsonObject::initialize(const std::string& inline_json) { + root = cJSON_Parse( inline_json.c_str() ); + if (!root) + throw std::invalid_argument("Parsing json input failed"); + owner = true; + } + + + JsonObject::JsonObject(const std::string& inline_json) { + initialize( inline_json ); + } + + JsonObject::JsonObject(const char * inline_json) { + initialize( inline_json ); + } + + + + JsonObject::JsonObject(const boost::filesystem::path& jsonFile ) { + std::ifstream stream(jsonFile.string().c_str()); + if (stream) { + std::string content_from_file( (std::istreambuf_iterator(stream)), + (std::istreambuf_iterator())); + initialize( content_from_file ); + } else + throw std::invalid_argument("Loading json from file: " + jsonFile.string() + " failed."); + } + + + + + JsonObject::JsonObject( cJSON * object ) { + root = object; + owner = false; + } + + + JsonObject::~JsonObject() { + if (owner && root) + cJSON_Delete(root); + } + + + + bool JsonObject::has_item( const std::string& key) const { + cJSON * object = cJSON_GetObjectItem( root , key.c_str() ); + if (object) + return true; + else + return false; + } + + + bool JsonObject::is_array( ) const { + if (root->type == cJSON_Array) + return true; + else + return false; + } + + bool JsonObject::is_number( ) const { + if (root->type == cJSON_Number) + return true; + else + return false; + } + + + bool JsonObject::is_string( ) const { + if (root->type == cJSON_String) + return true; + else + return false; + } + + bool JsonObject::is_object( ) const { + if (root->type == cJSON_Object) + return true; + else + return false; + } + + + size_t JsonObject::size() const { + int int_size = cJSON_GetArraySize( root ); + return (size_t) int_size; + } + + + JsonObject JsonObject::get_array_item( size_t index ) const { + if (is_array()) { + cJSON * new_c_ptr = cJSON_GetArrayItem( root , index ); + if (new_c_ptr) + return JsonObject( new_c_ptr ); + else + throw std::invalid_argument("Index is out ouf range."); + } else + throw std::invalid_argument("Object is not an array."); + } + + + JsonObject JsonObject::get_item(const std::string& key) const { + cJSON * c_ptr = cJSON_GetObjectItem( root , key.c_str() ); + if (c_ptr) + return JsonObject( c_ptr ); + else + throw std::invalid_argument("Key: " + key + " does not exist in json object"); + } + + + std::string JsonObject::get_string(const std::string& key) const { + JsonObject child = get_scalar_object( key ); + return child.as_string(); + } + + + std::string JsonObject::as_string() const { + if (is_string()) + return root->valuestring; + else + throw std::invalid_argument("Object is not a string object"); + } + + + int JsonObject::get_int(const std::string& key) const { + JsonObject child = get_scalar_object( key ); + return child.as_int( ); + } + + + int JsonObject::as_int() const { + if (root->type == cJSON_Number) + return root->valueint; + else + throw std::invalid_argument("Object is not a number object."); + } + + + double JsonObject::get_double(const std::string& key) const { + JsonObject child = get_scalar_object( key ); + return child.as_double( ); + } + + + double JsonObject::as_double() const { + if (root->type == cJSON_Number) + return root->valuedouble; + else + throw std::invalid_argument("Object is not a number object."); + } + + + JsonObject JsonObject::get_scalar_object(const std::string& key) const{ + JsonObject child = get_item( key ); + if (child.size()) + throw std::invalid_argument("Key: " + key + " is not a scalar object"); + else + return child; + } + + + + std::string JsonObject::to_string() const { + char * c_str = cJSON_Print( root ); + std::string s(c_str); + free( c_str ); + + return s; + } + + +} + diff --git a/ThirdParty/custom-opmjson/opm/json/JsonObject.hpp b/ThirdParty/custom-opmjson/opm/json/JsonObject.hpp new file mode 100644 index 0000000000..a9ce32c4d0 --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/JsonObject.hpp @@ -0,0 +1,74 @@ +/* + Copyright 2013 Statoil ASA. + + This file is part of the Open Porous Media project (OPM). + + OPM is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OPM is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OPM. If not, see . +*/ + +#ifndef JSON_OBJECT_HPP +#define JSON_OBJECT_HPP + +#include + +struct cJSON; + +namespace boost { + namespace filesystem { + class path; + } +} + +namespace Json { + + class JsonObject { + public: + explicit JsonObject(const boost::filesystem::path& jsonFile ); + explicit JsonObject(const std::string& inline_json); + explicit JsonObject(const char * inline_json); + explicit JsonObject(cJSON * root); + ~JsonObject(); + + bool has_item(const std::string& key) const; + JsonObject get_array_item( size_t index ) const; + JsonObject get_item(const std::string& key) const; + + std::string to_string() const; + std::string get_string(const std::string& key) const; + std::string as_string() const; + bool is_string( ) const; + + bool is_number( ) const; + int get_int(const std::string& key) const; + int as_int() const; + double get_double(const std::string& key) const; + double as_double() const; + + bool is_array( ) const; + bool is_object( ) const; + + size_t size() const; + private: + JsonObject get_scalar_object(const std::string& key) const; + void initialize(const std::string& inline_json); + cJSON * root; + bool owner; + }; +} + + + +#endif + + diff --git a/ThirdParty/custom-opmjson/opm/json/cjson/README b/ThirdParty/custom-opmjson/opm/json/cjson/README new file mode 100644 index 0000000000..59a8ac88cd --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/cjson/README @@ -0,0 +1,247 @@ +/* + Copyright (c) 2009 Dave Gamble + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +Welcome to cJSON. + +cJSON aims to be the dumbest possible parser that you can get your job done with. +It's a single file of C, and a single header file. + +JSON is described best here: http://www.json.org/ +It's like XML, but fat-free. You use it to move data around, store things, or just +generally represent your program's state. + + +First up, how do I build? +Add cJSON.c to your project, and put cJSON.h somewhere in the header search path. +For example, to build the test app: + +gcc cJSON.c test.c -o test -lm +./test + + +As a library, cJSON exists to take away as much legwork as it can, but not get in your way. +As a point of pragmatism (i.e. ignoring the truth), I'm going to say that you can use it +in one of two modes: Auto and Manual. Let's have a quick run-through. + + +I lifted some JSON from this page: http://www.json.org/fatfree.html +That page inspired me to write cJSON, which is a parser that tries to share the same +philosophy as JSON itself. Simple, dumb, out of the way. + +Some JSON: +{ + "name": "Jack (\"Bee\") Nimble", + "format": { + "type": "rect", + "width": 1920, + "height": 1080, + "interlace": false, + "frame rate": 24 + } +} + +Assume that you got this from a file, a webserver, or magic JSON elves, whatever, +you have a char * to it. Everything is a cJSON struct. +Get it parsed: + cJSON *root = cJSON_Parse(my_json_string); + +This is an object. We're in C. We don't have objects. But we do have structs. +What's the framerate? + + cJSON *format = cJSON_GetObjectItem(root,"format"); + int framerate = cJSON_GetObjectItem(format,"frame rate")->valueint; + + +Want to change the framerate? + cJSON_GetObjectItem(format,"frame rate")->valueint=25; + +Back to disk? + char *rendered=cJSON_Print(root); + +Finished? Delete the root (this takes care of everything else). + cJSON_Delete(root); + +That's AUTO mode. If you're going to use Auto mode, you really ought to check pointers +before you dereference them. If you want to see how you'd build this struct in code? + cJSON *root,*fmt; + root=cJSON_CreateObject(); + cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble")); + cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject()); + cJSON_AddStringToObject(fmt,"type", "rect"); + cJSON_AddNumberToObject(fmt,"width", 1920); + cJSON_AddNumberToObject(fmt,"height", 1080); + cJSON_AddFalseToObject (fmt,"interlace"); + cJSON_AddNumberToObject(fmt,"frame rate", 24); + +Hopefully we can agree that's not a lot of code? There's no overhead, no unnecessary setup. +Look at test.c for a bunch of nice examples, mostly all ripped off the json.org site, and +a few from elsewhere. + +What about manual mode? First up you need some detail. +Let's cover how the cJSON objects represent the JSON data. +cJSON doesn't distinguish arrays from objects in handling; just type. +Each cJSON has, potentially, a child, siblings, value, a name. + +The root object has: Object Type and a Child +The Child has name "name", with value "Jack ("Bee") Nimble", and a sibling: +Sibling has type Object, name "format", and a child. +That child has type String, name "type", value "rect", and a sibling: +Sibling has type Number, name "width", value 1920, and a sibling: +Sibling has type Number, name "height", value 1080, and a sibling: +Sibling hs type False, name "interlace", and a sibling: +Sibling has type Number, name "frame rate", value 24 + +Here's the structure: +typedef struct cJSON { + struct cJSON *next,*prev; + struct cJSON *child; + + int type; + + char *valuestring; + int valueint; + double valuedouble; + + char *string; +} cJSON; + +By default all values are 0 unless set by virtue of being meaningful. + +next/prev is a doubly linked list of siblings. next takes you to your sibling, +prev takes you back from your sibling to you. +Only objects and arrays have a "child", and it's the head of the doubly linked list. +A "child" entry will have prev==0, but next potentially points on. The last sibling has next=0. +The type expresses Null/True/False/Number/String/Array/Object, all of which are #defined in +cJSON.h + +A Number has valueint and valuedouble. If you're expecting an int, read valueint, if not read +valuedouble. + +Any entry which is in the linked list which is the child of an object will have a "string" +which is the "name" of the entry. When I said "name" in the above example, that's "string". +"string" is the JSON name for the 'variable name' if you will. + +Now you can trivially walk the lists, recursively, and parse as you please. +You can invoke cJSON_Parse to get cJSON to parse for you, and then you can take +the root object, and traverse the structure (which is, formally, an N-tree), +and tokenise as you please. If you wanted to build a callback style parser, this is how +you'd do it (just an example, since these things are very specific): + +void parse_and_callback(cJSON *item,const char *prefix) +{ + while (item) + { + char *newprefix=malloc(strlen(prefix)+strlen(item->name)+2); + sprintf(newprefix,"%s/%s",prefix,item->name); + int dorecurse=callback(newprefix, item->type, item); + if (item->child && dorecurse) parse_and_callback(item->child,newprefix); + item=item->next; + free(newprefix); + } +} + +The prefix process will build you a separated list, to simplify your callback handling. +The 'dorecurse' flag would let the callback decide to handle sub-arrays on it's own, or +let you invoke it per-item. For the item above, your callback might look like this: + +int callback(const char *name,int type,cJSON *item) +{ + if (!strcmp(name,"name")) { /* populate name */ } + else if (!strcmp(name,"format/type") { /* handle "rect" */ } + else if (!strcmp(name,"format/width") { /* 800 */ } + else if (!strcmp(name,"format/height") { /* 600 */ } + else if (!strcmp(name,"format/interlace") { /* false */ } + else if (!strcmp(name,"format/frame rate") { /* 24 */ } + return 1; +} + +Alternatively, you might like to parse iteratively. +You'd use: + +void parse_object(cJSON *item) +{ + int i; for (i=0;ichild; + while (subitem) + { + // handle subitem + if (subitem->child) parse_object(subitem->child); + + subitem=subitem->next; + } +} + +Of course, this should look familiar, since this is just a stripped-down version +of the callback-parser. + +This should cover most uses you'll find for parsing. The rest should be possible +to infer.. and if in doubt, read the source! There's not a lot of it! ;) + + +In terms of constructing JSON data, the example code above is the right way to do it. +You can, of course, hand your sub-objects to other functions to populate. +Also, if you find a use for it, you can manually build the objects. +For instance, suppose you wanted to build an array of objects? + +cJSON *objects[24]; + +cJSON *Create_array_of_anything(cJSON **items,int num) +{ + int i;cJSON *prev, *root=cJSON_CreateArray(); + for (i=0;i<24;i++) + { + if (!i) root->child=objects[i]; + else prev->next=objects[i], objects[i]->prev=prev; + prev=objects[i]; + } + return root; +} + +and simply: Create_array_of_anything(objects,24); + +cJSON doesn't make any assumptions about what order you create things in. +You can attach the objects, as above, and later add children to each +of those objects. + +As soon as you call cJSON_Print, it renders the structure to text. + + + +The test.c code shows how to handle a bunch of typical cases. If you uncomment +the code, it'll load, parse and print a bunch of test files, also from json.org, +which are more complex than I'd care to try and stash into a const char array[]. + + +Enjoy cJSON! + + +- Dave Gamble, Aug 2009 diff --git a/ThirdParty/custom-opmjson/opm/json/cjson/README.opm b/ThirdParty/custom-opmjson/opm/json/cjson/README.opm new file mode 100644 index 0000000000..06c6b87ae0 --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/cjson/README.opm @@ -0,0 +1,4 @@ +This directory contains the cJSON package downloaded unchanged from: +http://sourceforge.net/projects/cjson/. The cJSON package is plain C, +the JsonObject class provides a minimal C++ wrapping of this. + diff --git a/ThirdParty/custom-opmjson/opm/json/cjson/cJSON.c b/ThirdParty/custom-opmjson/opm/json/cjson/cJSON.c new file mode 100644 index 0000000000..96e503842d --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/cjson/cJSON.c @@ -0,0 +1,569 @@ +/* + Copyright (c) 2009 Dave Gamble + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +#include +#include +#include +#include +#include +#include +#include +#include "cJSON.h" + +static const char *ep; + +const char *cJSON_GetErrorPtr(void) {return ep;} + +static int cJSON_strcasecmp(const char *s1,const char *s2) +{ + if (!s1) return (s1==s2)?0:1;if (!s2) return 1; + for(; tolower(*s1) == tolower(*s2); ++s1, ++s2) if(*s1 == 0) return 0; + return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2); +} + +static void *(*cJSON_malloc)(size_t sz) = malloc; +static void (*cJSON_free)(void *ptr) = free; + +static char* cJSON_strdup(const char* str) +{ + size_t len; + char* copy; + + len = strlen(str) + 1; + if (!(copy = (char*)cJSON_malloc(len))) return 0; + memcpy(copy,str,len); + return copy; +} + +void cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (!hooks) { /* Reset hooks */ + cJSON_malloc = malloc; + cJSON_free = free; + return; + } + + cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc; + cJSON_free = (hooks->free_fn)?hooks->free_fn:free; +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(void) +{ + cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON)); + if (node) memset(node,0,sizeof(cJSON)); + return node; +} + +/* Delete a cJSON structure. */ +void cJSON_Delete(cJSON *c) +{ + cJSON *next; + while (c) + { + next=c->next; + if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child); + if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring); + if (c->string) cJSON_free(c->string); + cJSON_free(c); + c=next; + } +} + +/* Parse the input text to generate a number, and populate the result into item. */ +static const char *parse_number(cJSON *item,const char *num) +{ + double n=0,sign=1,scale=0;int subscale=0,signsubscale=1; + + /* Could use sscanf for this? */ + if (*num=='-') sign=-1,num++; /* Has sign? */ + if (*num=='0') num++; /* is zero */ + if (*num>='1' && *num<='9') do n=(n*10.0)+(*num++ -'0'); while (*num>='0' && *num<='9'); /* Number? */ + if (*num=='.' && num[1]>='0' && num[1]<='9') {num++; do n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');} /* Fractional part? */ + if (*num=='e' || *num=='E') /* Exponent? */ + { num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++; /* With sign? */ + while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0'); /* Number? */ + } + + n=sign*n*pow(10.0,(scale+subscale*signsubscale)); /* number = +/- number.fraction * 10^+/- exponent */ + + item->valuedouble=n; + item->valueint=(int)n; + item->type=cJSON_Number; + return num; +} + +/* Render the number nicely from the given item into a string. */ +static char *print_number(cJSON *item) +{ + char *str; + double d=item->valuedouble; + if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN) + { + str=(char*)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */ + if (str) sprintf(str,"%d",item->valueint); + } + else + { + str=(char*)cJSON_malloc(64); /* This is a nice tradeoff. */ + if (str) + { + if (fabs(floor(d)-d)<=DBL_EPSILON && fabs(d)<1.0e60)sprintf(str,"%.0f",d); + else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9) sprintf(str,"%e",d); + else sprintf(str,"%f",d); + } + } + return str; +} + +/* Parse the input text into an unescaped cstring, and populate item. */ +static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; +static const char *parse_string(cJSON *item,const char *str) +{ + const char *ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc,uc2; + if (*str!='\"') {ep=str;return 0;} /* not a string! */ + + while (*ptr!='\"' && *ptr && ++len) if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */ + + out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */ + if (!out) return 0; + + ptr=str+1;ptr2=out; + while (*ptr!='\"' && *ptr) + { + if (*ptr!='\\') *ptr2++=*ptr++; + else + { + ptr++; + switch (*ptr) + { + case 'b': *ptr2++='\b'; break; + case 'f': *ptr2++='\f'; break; + case 'n': *ptr2++='\n'; break; + case 'r': *ptr2++='\r'; break; + case 't': *ptr2++='\t'; break; + case 'u': /* transcode utf16 to utf8. */ + sscanf(ptr+1,"%4x",&uc);ptr+=4; /* get the unicode char. */ + + if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0) break; /* check for invalid. */ + + if (uc>=0xD800 && uc<=0xDBFF) /* UTF16 surrogate pairs. */ + { + if (ptr[1]!='\\' || ptr[2]!='u') break; /* missing second-half of surrogate. */ + sscanf(ptr+3,"%4x",&uc2);ptr+=6; + if (uc2<0xDC00 || uc2>0xDFFF) break; /* invalid second-half of surrogate. */ + uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF)); + } + + len=4;if (uc<0x80) len=1;else if (uc<0x800) len=2;else if (uc<0x10000) len=3; ptr2+=len; + + switch (len) { + case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; + case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; + case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; + case 1: *--ptr2 =(uc | firstByteMark[len]); + } + ptr2+=len; + break; + default: *ptr2++=*ptr; break; + } + ptr++; + } + } + *ptr2=0; + if (*ptr=='\"') ptr++; + item->valuestring=out; + item->type=cJSON_String; + return ptr; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static char *print_string_ptr(const char *str) +{ + const char *ptr;char *ptr2,*out;int len=0;unsigned char token; + + if (!str) return cJSON_strdup(""); + ptr=str;while ((token=*ptr) && ++len) {if (strchr("\"\\\b\f\n\r\t",token)) len++; else if (token<32) len+=5;ptr++;} + + out=(char*)cJSON_malloc(len+3); + if (!out) return 0; + + ptr2=out;ptr=str; + *ptr2++='\"'; + while (*ptr) + { + if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++; + else + { + *ptr2++='\\'; + switch (token=*ptr++) + { + case '\\': *ptr2++='\\'; break; + case '\"': *ptr2++='\"'; break; + case '\b': *ptr2++='b'; break; + case '\f': *ptr2++='f'; break; + case '\n': *ptr2++='n'; break; + case '\r': *ptr2++='r'; break; + case '\t': *ptr2++='t'; break; + default: sprintf(ptr2,"u%04x",token);ptr2+=5; break; /* escape and print */ + } + } + } + *ptr2++='\"';*ptr2++=0; + return out; +} +/* Invote print_string_ptr (which is useful) on an item. */ +static char *print_string(cJSON *item) {return print_string_ptr(item->valuestring);} + +/* Predeclare these prototypes. */ +static const char *parse_value(cJSON *item,const char *value); +static char *print_value(cJSON *item,int depth,int fmt); +static const char *parse_array(cJSON *item,const char *value); +static char *print_array(cJSON *item,int depth,int fmt); +static const char *parse_object(cJSON *item,const char *value); +static char *print_object(cJSON *item,int depth,int fmt); + +/* Utility to jump whitespace and cr/lf */ +static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;} + +/* Parse an object - create a new root, and populate. */ +cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated) +{ + const char *end=0; + cJSON *c=cJSON_New_Item(); + ep=0; + if (!c) return 0; /* memory fail */ + + end=parse_value(c,skip(value)); + if (!end) {cJSON_Delete(c);return 0;} /* parse failure. ep is set. */ + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}} + if (return_parse_end) *return_parse_end=end; + return c; +} +/* Default options for cJSON_Parse */ +cJSON *cJSON_Parse(const char *value) {return cJSON_ParseWithOpts(value,0,0);} + +/* Render a cJSON item/entity/structure to text. */ +char *cJSON_Print(cJSON *item) {return print_value(item,0,1);} +char *cJSON_PrintUnformatted(cJSON *item) {return print_value(item,0,0);} + +/* Parser core - when encountering text, process appropriately. */ +static const char *parse_value(cJSON *item,const char *value) +{ + if (!value) return 0; /* Fail on null. */ + if (!strncmp(value,"null",4)) { item->type=cJSON_NULL; return value+4; } + if (!strncmp(value,"false",5)) { item->type=cJSON_False; return value+5; } + if (!strncmp(value,"true",4)) { item->type=cJSON_True; item->valueint=1; return value+4; } + if (*value=='\"') { return parse_string(item,value); } + if (*value=='-' || (*value>='0' && *value<='9')) { return parse_number(item,value); } + if (*value=='[') { return parse_array(item,value); } + if (*value=='{') { return parse_object(item,value); } + + ep=value;return 0; /* failure. */ +} + +/* Render a value to text. */ +static char *print_value(cJSON *item,int depth,int fmt) +{ + char *out=0; + if (!item) return 0; + switch ((item->type)&255) + { + case cJSON_NULL: out=cJSON_strdup("null"); break; + case cJSON_False: out=cJSON_strdup("false");break; + case cJSON_True: out=cJSON_strdup("true"); break; + case cJSON_Number: out=print_number(item);break; + case cJSON_String: out=print_string(item);break; + case cJSON_Array: out=print_array(item,depth,fmt);break; + case cJSON_Object: out=print_object(item,depth,fmt);break; + } + return out; +} + +/* Build an array from input text. */ +static const char *parse_array(cJSON *item,const char *value) +{ + cJSON *child; + if (*value!='[') {ep=value;return 0;} /* not an array! */ + + item->type=cJSON_Array; + value=skip(value+1); + if (*value==']') return value+1; /* empty array. */ + + item->child=child=cJSON_New_Item(); + if (!item->child) return 0; /* memory fail */ + value=skip(parse_value(child,skip(value))); /* skip any spacing, get the value. */ + if (!value) return 0; + + while (*value==',') + { + cJSON *new_item; + if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */ + child->next=new_item;new_item->prev=child;child=new_item; + value=skip(parse_value(child,skip(value+1))); + if (!value) return 0; /* memory fail */ + } + + if (*value==']') return value+1; /* end of array */ + ep=value;return 0; /* malformed. */ +} + +/* Render an array to text */ +static char *print_array(cJSON *item,int depth,int fmt) +{ + char **entries; + char *out=0,*ptr,*ret;int len=5; + cJSON *child=item->child; + int numentries=0,i=0,fail=0; + + /* How many entries in the array? */ + while (child) numentries++,child=child->next; + /* Explicitly handle numentries==0 */ + if (!numentries) + { + out=(char*)cJSON_malloc(3); + if (out) strcpy(out,"[]"); + return out; + } + /* Allocate an array to hold the values for each */ + entries=(char**)cJSON_malloc(numentries*sizeof(char*)); + if (!entries) return 0; + memset(entries,0,numentries*sizeof(char*)); + /* Retrieve all the results: */ + child=item->child; + while (child && !fail) + { + ret=print_value(child,depth+1,fmt); + entries[i++]=ret; + if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1; + child=child->next; + } + + /* If we didn't fail, try to malloc the output string */ + if (!fail) out=(char*)cJSON_malloc(len); + /* If that fails, we fail. */ + if (!out) fail=1; + + /* Handle failure. */ + if (fail) + { + for (i=0;itype=cJSON_Object; + value=skip(value+1); + if (*value=='}') return value+1; /* empty array. */ + + item->child=child=cJSON_New_Item(); + if (!item->child) return 0; + value=skip(parse_string(child,skip(value))); + if (!value) return 0; + child->string=child->valuestring;child->valuestring=0; + if (*value!=':') {ep=value;return 0;} /* fail! */ + value=skip(parse_value(child,skip(value+1))); /* skip any spacing, get the value. */ + if (!value) return 0; + + while (*value==',') + { + cJSON *new_item; + if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */ + child->next=new_item;new_item->prev=child;child=new_item; + value=skip(parse_string(child,skip(value+1))); + if (!value) return 0; + child->string=child->valuestring;child->valuestring=0; + if (*value!=':') {ep=value;return 0;} /* fail! */ + value=skip(parse_value(child,skip(value+1))); /* skip any spacing, get the value. */ + if (!value) return 0; + } + + if (*value=='}') return value+1; /* end of array */ + ep=value;return 0; /* malformed. */ +} + +/* Render an object to text. */ +static char *print_object(cJSON *item,int depth,int fmt) +{ + char **entries=0,**names=0; + char *out=0,*ptr,*ret,*str;int len=7,i=0,j; + cJSON *child=item->child; + int numentries=0,fail=0; + /* Count the number of entries. */ + while (child) numentries++,child=child->next; + /* Explicitly handle empty object case */ + if (!numentries) + { + out=(char*)cJSON_malloc(fmt?depth+3:3); + if (!out) return 0; + ptr=out;*ptr++='{'; + if (fmt) {*ptr++='\n';for (i=0;ichild;depth++;if (fmt) len+=depth; + while (child) + { + names[i]=str=print_string_ptr(child->string); + entries[i++]=ret=print_value(child,depth,fmt); + if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1; + child=child->next; + } + + /* Try to allocate the output string */ + if (!fail) out=(char*)cJSON_malloc(len); + if (!out) fail=1; + + /* Handle failure */ + if (fail) + { + for (i=0;ichild;int i=0;while(c)i++,c=c->next;return i;} +cJSON *cJSON_GetArrayItem(cJSON *array,int item) {cJSON *c=array->child; while (c && item>0) item--,c=c->next; return c;} +cJSON *cJSON_GetObjectItem(cJSON *object,const char *string) {cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;} +/* Utility for handling references. */ +static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();if (!ref) return 0;memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;} + +/* Add item to array/object. */ +void cJSON_AddItemToArray(cJSON *array, cJSON *item) {cJSON *c=array->child;if (!item) return; if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}} +void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item) {if (!item) return; if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);} +void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) {cJSON_AddItemToArray(array,create_reference(item));} +void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item) {cJSON_AddItemToObject(object,string,create_reference(item));} + +cJSON *cJSON_DetachItemFromArray(cJSON *array,int which) {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0; + if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;} +void cJSON_DeleteItemFromArray(cJSON *array,int which) {cJSON_Delete(cJSON_DetachItemFromArray(array,which));} +cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;} +void cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));} + +/* Replace array/object items with new ones. */ +void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem) {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return; + newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem; + if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);} +void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}} + +/* Create basic types: */ +cJSON *cJSON_CreateNull(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;} +cJSON *cJSON_CreateTrue(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;} +cJSON *cJSON_CreateFalse(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;} +cJSON *cJSON_CreateBool(int b) {cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;} +cJSON *cJSON_CreateNumber(double num) {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;}return item;} +cJSON *cJSON_CreateString(const char *string) {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;} +cJSON *cJSON_CreateArray(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Array;return item;} +cJSON *cJSON_CreateObject(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Object;return item;} + +/* Create Arrays: */ +cJSON *cJSON_CreateIntArray(int *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && ichild=n;else suffix_object(p,n);p=n;}return a;} +cJSON *cJSON_CreateFloatArray(float *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && ichild=n;else suffix_object(p,n);p=n;}return a;} +cJSON *cJSON_CreateDoubleArray(double *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && ichild=n;else suffix_object(p,n);p=n;}return a;} +cJSON *cJSON_CreateStringArray(const char **strings,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && ichild=n;else suffix_object(p,n);p=n;}return a;} + +/* Duplication */ +cJSON *cJSON_Duplicate(cJSON *item,int recurse) +{ + cJSON *newitem,*cptr,*nptr=0,*newchild; + /* Bail on bad ptr */ + if (!item) return 0; + /* Create new item */ + newitem=cJSON_New_Item(); + if (!newitem) return 0; + /* Copy over all vars */ + newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble; + if (item->valuestring) {newitem->valuestring=cJSON_strdup(item->valuestring); if (!newitem->valuestring) {cJSON_Delete(newitem);return 0;}} + if (item->string) {newitem->string=cJSON_strdup(item->string); if (!newitem->string) {cJSON_Delete(newitem);return 0;}} + /* If non-recursive, then we're done! */ + if (!recurse) return newitem; + /* Walk the ->next chain for the child. */ + cptr=item->child; + while (cptr) + { + newchild=cJSON_Duplicate(cptr,1); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) {cJSON_Delete(newitem);return 0;} + if (nptr) {nptr->next=newchild,newchild->prev=nptr;nptr=newchild;} /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + else {newitem->child=newchild;nptr=newchild;} /* Set newitem->child and move to it */ + cptr=cptr->next; + } + return newitem; +} + + diff --git a/ThirdParty/custom-opmjson/opm/json/cjson/cJSON.h b/ThirdParty/custom-opmjson/opm/json/cjson/cJSON.h new file mode 100644 index 0000000000..2f61096a3d --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/cjson/cJSON.h @@ -0,0 +1,143 @@ +/* + Copyright (c) 2009 Dave Gamble + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* cJSON Types: */ +#define cJSON_False 0 +#define cJSON_True 1 +#define cJSON_NULL 2 +#define cJSON_Number 3 +#define cJSON_String 4 +#define cJSON_Array 5 +#define cJSON_Object 6 + +#define cJSON_IsReference 256 + +/* The cJSON structure: */ +typedef struct cJSON { + struct cJSON *next,*prev; /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *child; /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + + int type; /* The type of the item, as above. */ + + char *valuestring; /* The item's string, if type==cJSON_String */ + int valueint; /* The item's number, if type==cJSON_Number */ + double valuedouble; /* The item's number, if type==cJSON_Number */ + + char *string; /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ +} cJSON; + +typedef struct cJSON_Hooks { + void *(*malloc_fn)(size_t sz); + void (*free_fn)(void *ptr); +} cJSON_Hooks; + +/* Supply malloc, realloc and free functions to cJSON */ +extern void cJSON_InitHooks(cJSON_Hooks* hooks); + + +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. */ +extern cJSON *cJSON_Parse(const char *value); +/* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */ +extern char *cJSON_Print(cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished. */ +extern char *cJSON_PrintUnformatted(cJSON *item); +/* Delete a cJSON entity and all subentities. */ +extern void cJSON_Delete(cJSON *c); + +/* Returns the number of items in an array (or object). */ +extern int cJSON_GetArraySize(cJSON *array); +/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */ +extern cJSON *cJSON_GetArrayItem(cJSON *array,int item); +/* Get item "string" from object. Case insensitive. */ +extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string); + +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +extern const char *cJSON_GetErrorPtr(void); + +/* These calls create a cJSON item of the appropriate type. */ +extern cJSON *cJSON_CreateNull(void); +extern cJSON *cJSON_CreateTrue(void); +extern cJSON *cJSON_CreateFalse(void); +extern cJSON *cJSON_CreateBool(int b); +extern cJSON *cJSON_CreateNumber(double num); +extern cJSON *cJSON_CreateString(const char *string); +extern cJSON *cJSON_CreateArray(void); +extern cJSON *cJSON_CreateObject(void); + +/* These utilities create an Array of count items. */ +extern cJSON *cJSON_CreateIntArray(int *numbers,int count); +extern cJSON *cJSON_CreateFloatArray(float *numbers,int count); +extern cJSON *cJSON_CreateDoubleArray(double *numbers,int count); +extern cJSON *cJSON_CreateStringArray(const char **strings,int count); + +/* Append item to the specified array/object. */ +extern void cJSON_AddItemToArray(cJSON *array, cJSON *item); +extern void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +extern void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item); + +/* Remove/Detatch items from Arrays/Objects. */ +extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int which); +extern void cJSON_DeleteItemFromArray(cJSON *array,int which); +extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string); +extern void cJSON_DeleteItemFromObject(cJSON *object,const char *string); + +/* Update array items. */ +extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem); +extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +extern cJSON *cJSON_Duplicate(cJSON *item,int recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will +need to be released. With recurse!=0, it will duplicate any children connected to the item. +The item->next and ->prev pointers are always zero on return from Duplicate. */ + +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +extern cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated); + +/* Macros for creating things quickly. */ +#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull()) +#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue()) +#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse()) +#define cJSON_AddBoolToObject(object,name,b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b)) +#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n)) +#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s)) + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object,val) ((object)?(object)->valueint=(object)->valuedouble=(val):(val)) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ThirdParty/custom-opmjson/opm/json/tests/CMakeLists.txt b/ThirdParty/custom-opmjson/opm/json/tests/CMakeLists.txt new file mode 100644 index 0000000000..37e504966e --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/tests/CMakeLists.txt @@ -0,0 +1,5 @@ +opm_add_test(runjsonTests SOURCES jsonTests.cpp + LIBRARIES opmjson ${Boost_LIBRARIES}) +if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows") + set_source_files_properties( jsonTests.cpp PROPERTIES COMPILE_FLAGS "-Wno-unused-variable") +endif() diff --git a/ThirdParty/custom-opmjson/opm/json/tests/jsonTests.cpp b/ThirdParty/custom-opmjson/opm/json/tests/jsonTests.cpp new file mode 100644 index 0000000000..a76ab07581 --- /dev/null +++ b/ThirdParty/custom-opmjson/opm/json/tests/jsonTests.cpp @@ -0,0 +1,281 @@ +/* + Copyright 2013 Statoil ASA. + + This file is part of the Open Porous Media project (OPM). + + OPM is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OPM is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OPM. If not, see . + */ +#include +#include +#include + +#define BOOST_TEST_MODULE jsonParserTests +#include +#include + +#include + +#include + + + + + +BOOST_AUTO_TEST_CASE(ParseValidJson) { + std::string inline_json = "{\"key\": \"value\"}"; + BOOST_CHECK_NO_THROW(Json::JsonObject parser(inline_json)); +} + + +BOOST_AUTO_TEST_CASE(ParseValidJson_fromLiteral) { + BOOST_CHECK_NO_THROW(Json::JsonObject parser("{\"key\": \"value\"}")); +} + + + +BOOST_AUTO_TEST_CASE(ParseInvalidJSON_throw) { + std::string inline_json = "{\"key\": \"value\""; + BOOST_CHECK_THROW(Json::JsonObject parser(inline_json) , std::invalid_argument); +} + + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_getString) { + std::string inline_json = "{\"key\": \"value\"}"; + Json::JsonObject parser(inline_json); + + BOOST_CHECK_EQUAL( "value" , parser.get_string("key") ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSONString_asString) { + std::string inline_json = "{\"key\": \"value\"}"; + Json::JsonObject parser(inline_json); + Json::JsonObject value = parser.get_item("key"); + + BOOST_CHECK_EQUAL( "value" , value.as_string() ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSONnotString_asString_throws) { + std::string inline_json = "{\"key\": 100}"; + Json::JsonObject parser(inline_json); + Json::JsonObject value = parser.get_item("key"); + + BOOST_CHECK_THROW( value.as_string() , std::invalid_argument ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSONint_asNumber) { + std::string inline_json = "{\"key1\": 100, \"key2\" : 100.100 }"; + Json::JsonObject parser(inline_json); + Json::JsonObject value1 = parser.get_item("key1"); + Json::JsonObject value2 = parser.get_item("key2"); + + BOOST_CHECK_EQUAL( 100 , value1.as_int() ); + BOOST_CHECK( fabs(100.100 - value2.as_double()) < 0.00001 ); +} + +BOOST_AUTO_TEST_CASE(ParsevalidJSONint_isNumber) { + std::string inline_json = "{\"key1\": 100, \"key2\" : 100.100 , \"key3\": \"string\"}"; + Json::JsonObject parser(inline_json); + Json::JsonObject value1 = parser.get_item("key1"); + Json::JsonObject value2 = parser.get_item("key2"); + Json::JsonObject value3 = parser.get_item("key3"); + + BOOST_CHECK( value1.is_number()) ; + BOOST_CHECK( value2.is_number()) ; + BOOST_CHECK_EQUAL( false , value3.is_number()) ; +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSONnotNumber_asNumber_throws) { + std::string inline_json = "{\"key\": \"100X\"}"; + Json::JsonObject parser(inline_json); + Json::JsonObject value = parser.get_item("key"); + + BOOST_CHECK_THROW( value.as_int() , std::invalid_argument ); + BOOST_CHECK_THROW( value.as_double() , std::invalid_argument ); +} + + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_getInt_OK) { + std::string inline_json = "{\"key1\": 100 , \"key2\" : 200}"; + Json::JsonObject parser(inline_json); + BOOST_CHECK_EQUAL( 100 , parser.get_int("key1") ); + BOOST_CHECK_EQUAL( 200 , parser.get_int("key2") ); +} + + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_hasItem) { + std::string inline_json = "{\"key\": \"value\"}"; + Json::JsonObject parser(inline_json); + BOOST_CHECK( parser.has_item("key")); + BOOST_CHECK_EQUAL( false , parser.has_item("keyX")); +} + + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_getMissingValue) { + std::string inline_json = "{\"key\": \"value\"}"; + Json::JsonObject parser(inline_json); + BOOST_CHECK_THROW( parser.get_string("keyX") , std::invalid_argument ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_getNotScalar_throws) { + std::string inline_json = "{\"key\": \"value\", \"list\": [1,2,3]}"; + Json::JsonObject parser(inline_json); + BOOST_CHECK_EQUAL( "value" , parser.get_string("key")); + BOOST_CHECK_THROW( parser.get_string("list") , std::invalid_argument ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_getObject) { + std::string inline_json = "{\"key\": \"value\", \"list\": [1,2,3]}"; + Json::JsonObject parser(inline_json); + BOOST_CHECK_NO_THROW( Json::JsonObject object = parser.get_item("list") ); + BOOST_CHECK_NO_THROW( Json::JsonObject object = parser.get_item("key") ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_getObject_missing_throw) { + std::string inline_json = "{\"key\": \"value\", \"list\": [1,2,3]}"; + Json::JsonObject parser(inline_json); + BOOST_CHECK_THROW( parser.get_item("listX") , std::invalid_argument ); +} + + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_CheckArraySize) { + std::string inline_json = "{\"key\": \"value\", \"list\": [1,2,3]}"; + Json::JsonObject parser(inline_json); + Json::JsonObject object = parser.get_item("list"); + BOOST_CHECK_EQUAL( 3U , object.size() ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_isArray){ + std::string inline_json = "{\"key\": \"value\", \"list\": [1,2,3]}"; + Json::JsonObject parser(inline_json); + Json::JsonObject list = parser.get_item("list"); + Json::JsonObject key = parser.get_item("key"); + + BOOST_CHECK( list.is_array() ); + BOOST_CHECK_EQUAL( false , key.is_array( ) ); +} + + +BOOST_AUTO_TEST_CASE(ParsevalidJSON_arrayGet) { + std::string inline_json = "{\"key\": \"value\", \"list\": [1,2,3]}"; + Json::JsonObject parser(inline_json); + Json::JsonObject list = parser.get_item("list"); + Json::JsonObject key = parser.get_item("key"); + + BOOST_CHECK_NO_THROW( list.get_array_item( 0U )); + BOOST_CHECK_NO_THROW( list.get_array_item( 1U )); + BOOST_CHECK_NO_THROW( list.get_array_item( 2U )); + + BOOST_CHECK_THROW( list.get_array_item( 3U ) , std::invalid_argument ); + BOOST_CHECK_THROW( key.get_array_item( 0U ) , std::invalid_argument ); +} + + +BOOST_AUTO_TEST_CASE(parseJSONString_testType) { + std::string inline_json = "{\"item\": \"string\"}"; + Json::JsonObject json(inline_json); + Json::JsonObject item = json.get_item( "item" ); + + BOOST_CHECK( item.is_string() ); + BOOST_CHECK_EQUAL( false , item.is_number( ) ); + BOOST_CHECK_EQUAL( false , item.is_array( ) ); + BOOST_CHECK_EQUAL( false , item.is_object( ) ); +} + + +BOOST_AUTO_TEST_CASE(parseJSONNumber_testType) { + std::string inline_json = "{\"item\": 100}"; + Json::JsonObject json(inline_json); + Json::JsonObject item = json.get_item( "item" ); + + BOOST_CHECK_EQUAL( true , item.is_number( ) ); + BOOST_CHECK_EQUAL( false , item.is_string() ); + BOOST_CHECK_EQUAL( false , item.is_array( ) ); + BOOST_CHECK_EQUAL( false , item.is_object( ) ); +} + + +BOOST_AUTO_TEST_CASE(parseJSONArray_testType) { + std::string inline_json = "{\"item\": [1,2,3]}"; + Json::JsonObject json(inline_json); + Json::JsonObject item = json.get_item( "item" ); + + BOOST_CHECK_EQUAL( false , item.is_number( ) ); + BOOST_CHECK_EQUAL( false , item.is_string() ); + BOOST_CHECK_EQUAL( true , item.is_array( ) ); + BOOST_CHECK_EQUAL( false , item.is_object( ) ); +} + + +BOOST_AUTO_TEST_CASE(parseJSONObject_testType) { + std::string inline_json = "{\"item\": {\"list\": [0,1,2]}}"; + Json::JsonObject json(inline_json); + Json::JsonObject item = json.get_item( "item" ); + + BOOST_CHECK_EQUAL( false , item.is_number( ) ); + BOOST_CHECK_EQUAL( false , item.is_string() ); + BOOST_CHECK_EQUAL( false , item.is_array( ) ); + BOOST_CHECK_EQUAL( true , item.is_object( ) ); +} + + + +BOOST_AUTO_TEST_CASE(Parse_fileDoesNotExist_Throws) { + boost::filesystem::path jsonFile("file/does/not/exist"); + BOOST_CHECK_THROW( Json::JsonObject parser(jsonFile) , std::invalid_argument); +} + + + +BOOST_AUTO_TEST_CASE(Parse_fileExists_OK) { + boost::filesystem::path jsonFile("testdata/json/example1.json"); + BOOST_CHECK_NO_THROW( Json::JsonObject parser(jsonFile) ); +} + + +BOOST_AUTO_TEST_CASE(to_string_ok) { + boost::filesystem::path jsonFile("testdata/json/example1.json"); + Json::JsonObject parser(jsonFile); + std::string json_string = + "{\n" + " \"keywords\": [{\n" + " \"name\": \"BPR\",\n" + " \"items\": [{\n" + " \"name\": \"ItemX\",\n" + " \"size_type\": \"SINGLE\",\n" + " \"value_type\": \"FLOAT\"\n" + " }]\n" + " }, {\n" + " \"name\": \"WWCT\",\n" + " \"size\": 0\n" + " }]\n" + "}"; + + BOOST_CHECK_EQUAL( parser.to_string() , json_string); +} + + +