RepoMirrors/cJSON
1
0
Fork 0
mirror of https://github.com/DaveGamble/cJSON synced 2025-04-11 03:32:22 +00:00
Code Issues Releases Wiki Activity

Add more patch functionality and some more utils.

Browse Source 
Also add a new #define to cJSON.h for SetNumberValue.


git-svn-id: svn://svn.code.sf.net/p/cjson/code@66 e3330c51-1366-4df0-8b21-3ccf24e3d50e
This commit is contained in:
Dave Gamble 2015-02-11 01:29:40 +00:00
parent 3c6b3cc617
commit 060e6563c0
4 changed files with 201 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cJSON.h
View File

@ -140,6 +140,7 @@ extern void cJSON_Minify(char *json);
/* 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))
#define cJSON_SetNumberValue(object,val) ((object)?(object)->valueint=(object)->valuedouble=(val):(val))
#ifdef __cplusplus
}

165
cJSON_Utils.c
View File

@ -1,6 +1,7 @@
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "cJSON_Utils.h"
// JSON Pointer implementation:
@ -15,23 +16,65 @@ static int cJSONUtils_Pstrcasecmp(const char *a,const char *e)
return 0;
}
static int cJSONUtils_PointerEncodedstrlen(const char *s) {int l=0;for (;*s;s++,l++) if (*s=='~' || *s=='/') l++;return l;}
static void cJSONUtils_PointerEncodedstrcpy(char *d,const char *s)
{
for (;*s;s++)
{
if (*s=='/') {*d++='~';*d++='1';}
else if (*s=='~') {*d++='~';*d++='0';}
else *d++=*s;
}
*d=0;
}
char *cJSONUtils_FindPointerFromObjectTo(cJSON *object,cJSON *target)
{
if (object==target) return strdup("");
int type=object->type,c=0;
for (cJSON *obj=object->child;obj;obj=obj->next,c++)
{
char *found=cJSONUtils_FindPointerFromObjectTo(obj,target);
if (found)
{
if (type==cJSON_Array)
{
char *ret=(char*)malloc(strlen(found)+23);
sprintf(ret,"/%d%s",c,found);
free(found);
return ret;
}
else if (type==cJSON_Object)
{
char *ret=(char*)malloc(strlen(found)+cJSONUtils_PointerEncodedstrlen(obj->string)+2);
*ret='/';cJSONUtils_PointerEncodedstrcpy(ret+1,obj->string);
strcat(ret,found);
free(found);
return ret;
}
free(found);
return 0;
}
}
return 0;
}
cJSON *cJSONUtils_GetPointer(cJSON *object,const char *pointer)
{
cJSON *target=object;int which=0;const char *element=0;
while (*pointer=='/' && object)
while (*pointer++=='/' && object)
{
pointer++;
if (object->type==cJSON_Array)
{
which=0; while (*pointer>='0' && *pointer<='9') which=(10*which) + *pointer++ - '0';
int which=0; while (*pointer>='0' && *pointer<='9') which=(10*which) + *pointer++ - '0';
if (*pointer && *pointer!='/') return 0;
object=cJSON_GetArrayItem(object,which);
}
else if (object->type==cJSON_Object)
{
element=pointer; while (*pointer && *pointer!='/') pointer++;
object=object->child; while (object && cJSONUtils_Pstrcasecmp(object->string,element)) object=object->next; // GetObjectItem.
object=object->child; while (object && cJSONUtils_Pstrcasecmp(object->string,pointer)) object=object->next; // GetObjectItem.
while (*pointer && *pointer!='/') pointer++;
}
else return 0;
}
@ -42,8 +85,7 @@ cJSON *cJSONUtils_GetPointer(cJSON *object,const char *pointer)
static void cJSONUtils_InplaceDecodePointerString(char *string)
{
char *s2=string;
for (;*string;s2++,string++)
*s2=(*string!='~')?(*string):((*(++string)=='0')?'~':'/');
for (;*string;s2++,string++) *s2=(*string!='~')?(*string):((*(++string)=='0')?'~':'/');
*s2=0;
}
@ -63,6 +105,28 @@ static cJSON *cJSONUtils_PatchDetach(cJSON *object,const char *path)
return ret;
}
static int cJSONUtils_Compare(cJSON *a,cJSON *b)
{
if (a->type!=b->type) return -1; // mismatched type.
switch (a->type)
{
case cJSON_Number: return (a->valueint!=b->valueint || a->valuedouble!=b->valuedouble)?-2:0; // numeric mismatch.
case cJSON_String: return (strcmp(a->valuestring,b->valuestring)!=0)?-3:0; // string mismatch.
case cJSON_Array: for (a=a->child,b=b->child;a && b;a=a->next,b=b->next) {int err=cJSONUtils_Compare(a,b);if (err) return err;}
return (a || b)?-4:0; // array size mismatch.
case cJSON_Object:
if (cJSON_GetArraySize(a)!=cJSON_GetArraySize(b)) return -5; // object length mismatch.
for (a=a->child;a;a=a->next)
{
int err=0;cJSON *s=cJSON_GetObjectItem(b,a->string); if (!s) return -6; // missing object member.
err=cJSONUtils_Compare(a,s);if (err) return err;
}
return 0;
default: break;
}
return 0;
}
static int cJSONUtils_ApplyPatch(cJSON *object,cJSON *patch)
{
cJSON *op=0,*path=0,*value=0;int opcode=0;
@ -76,10 +140,8 @@ static int cJSONUtils_ApplyPatch(cJSON *object,cJSON *patch)
else if (!strcmp(op->valuestring,"replace"))opcode=2;
else if (!strcmp(op->valuestring,"move")) opcode=3;
else if (!strcmp(op->valuestring,"copy")) opcode=4;
else if (!strcmp(op->valuestring,"test")) opcode=5;
else if (!strcmp(op->valuestring,"test")) return cJSONUtils_Compare(cJSONUtils_GetPointer(object,path->valuestring),cJSON_GetObjectItem(patch,"value"));
else return 3; // unknown opcode.
if (opcode==5) return 10; // TEST IS CURRENTLY UNIMPLEMENTED.
if (opcode==1 || opcode==2) // Remove/Replace
{
@ -142,3 +204,82 @@ int cJSONUtils_ApplyPatches(cJSON *object,cJSON *patches)
return 0;
}
static void cJSONUtils_GeneratePatch(cJSON *patches,const char *op,const char *path,const char *suffix,cJSON *val)
{
cJSON *patch=cJSON_CreateObject();
cJSON_AddItemToObject(patch,"op",cJSON_CreateString(op));
if (suffix)
{
char *newpath=(char*)malloc(strlen(path)+cJSONUtils_PointerEncodedstrlen(suffix)+2);
cJSONUtils_PointerEncodedstrcpy(newpath+sprintf(newpath,"%s/",path),suffix);
cJSON_AddItemToObject(patch,"path",cJSON_CreateString(newpath));
free(newpath);
}
else cJSON_AddItemToObject(patch,"path",cJSON_CreateString(path));
if (val) cJSON_AddItemToObject(patch,"value",cJSON_Duplicate(val,1));
cJSON_AddItemToArray(patches,patch);
}
void cJSONUtils_AddPatchToArray(cJSON *array,const char *op,const char *path,cJSON *val) {cJSONUtils_GeneratePatch(array,op,path,0,val);}
static void cJSONUtils_CompareToPatch(cJSON *patches,const char *path,cJSON *from,cJSON *to)
{
if (from->type!=to->type) {cJSONUtils_GeneratePatch(patches,"replace",path,0,to); return; }
switch (from->type)
{
case cJSON_Number:
if (from->valueint!=to->valueint || from->valuedouble!=to->valuedouble)
cJSONUtils_GeneratePatch(patches,"replace",path,0,to);
return;
case cJSON_String:
if (strcmp(from->valuestring,to->valuestring)!=0)
cJSONUtils_GeneratePatch(patches,"replace",path,0,to);
return;
case cJSON_Array:
{
int c;char *newpath=(char*)malloc(strlen(path)+23); // Allow space for 64bit int.
for (c=0,from=from->child,to=to->child;from && to;from=from->next,to=to->next,c++){
sprintf(newpath,"%s/%d",path,c); cJSONUtils_CompareToPatch(patches,newpath,from,to);
}
for (;from;from=from->next,c++) {sprintf(newpath,"%d",c); cJSONUtils_GeneratePatch(patches,"remove",path,newpath,0); }
for (;to;to=to->next,c++) cJSONUtils_GeneratePatch(patches,"add",path,"-",to);
free(newpath);
return;
}
case cJSON_Object:
for (cJSON *a=from->child;a;a=a->next)
{
if (!cJSON_GetObjectItem(to,a->string)) cJSONUtils_GeneratePatch(patches,"remove",path,a->string,0);
}
for (cJSON *a=to->child;a;a=a->next)
{
cJSON *other=cJSON_GetObjectItem(from,a->string);
if (!other) cJSONUtils_GeneratePatch(patches,"add",path,a->string,a);
else
{
char *newpath=(char*)malloc(strlen(path)+cJSONUtils_PointerEncodedstrlen(a->string)+2);
cJSONUtils_PointerEncodedstrcpy(newpath+sprintf(newpath,"%s/",path),a->string);
cJSONUtils_CompareToPatch(patches,newpath,other,a);
free(newpath);
}
}
return;
default: break;
}
}
cJSON* cJSONUtils_GeneratePatches(cJSON *from,cJSON *to)
{
cJSON *patches=cJSON_CreateArray();
cJSONUtils_CompareToPatch(patches,"",from,to);
return patches;
}

5
cJSON_Utils.h
View File

@ -4,7 +4,8 @@
cJSON *cJSONUtils_GetPointer(cJSON *object,const char *pointer);
// Implement RFC6902 (https://tools.ietf.org/html/rfc6902) JSON Patch spec.
//cJSON* cJSONUtils_GeneratePatches(cJSON *from,cJSON *to); // Not yet implemented.
cJSON* cJSONUtils_GeneratePatches(cJSON *from,cJSON *to);
void cJSONUtils_AddPatchToArray(cJSON *array,const char *op,const char *path,cJSON *val); // Utility for generating patch array entries.
int cJSONUtils_ApplyPatches(cJSON *object,cJSON *patches); // Returns 0 for success.
// Note that ApplyPatches is NOT atomic on failure. To implement an atomic ApplyPatches, use:
@ -17,3 +18,5 @@ int cJSONUtils_ApplyPatches(cJSON *object,cJSON *patches); // Returns 0 for succ
// return error;
//}
// Code not added to library since this strategy is a LOT slower.
char *cJSONUtils_FindPointerFromObjectTo(cJSON *object,cJSON *target); // Given a root object and a target object, construct a pointer from one to the other.

62
test_utils.c
View File

@ -1,5 +1,6 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "cJSON_Utils.h"
int main()
@ -30,25 +31,25 @@ int main()
}
cJSON_Delete(root);
// JSON Patch tests:
const char *patches[15][2]={
{"{ \"foo\": \"bar\"}", "[{ \"op\": \"add\", \"path\": \"/baz\", \"value\": \"qux\" }]"},
{"{ \"foo\": [ \"bar\", \"baz\" ] }", "[{ \"op\": \"add\", \"path\": \"/foo/1\", \"value\": \"qux\" }]"},
{"{\"baz\": \"qux\",\"foo\": \"bar\"}"," [{ \"op\": \"remove\", \"path\": \"/baz\" }]"},
{"{ \"foo\": [ \"bar\", \"qux\", \"baz\" ] }","[{ \"op\": \"remove\", \"path\": \"/foo/1\" }]"},
{"{ \"baz\": \"qux\",\"foo\": \"bar\"}","[{ \"op\": \"replace\", \"path\": \"/baz\", \"value\": \"boo\" }]"},
{"{\"foo\": {\"bar\": \"baz\",\"waldo\": \"fred\"},\"qux\": {\"corge\": \"grault\"}}","[{ \"op\": \"move\", \"from\": \"/foo/waldo\", \"path\": \"/qux/thud\" }]"},
{"{ \"foo\": [ \"all\", \"grass\", \"cows\", \"eat\" ] }","[ { \"op\": \"move\", \"from\": \"/foo/1\", \"path\": \"/foo/3\" }]"},
{"{\"baz\": \"qux\",\"foo\": [ \"a\", 2, \"c\" ]}","[{ \"op\": \"test\", \"path\": \"/baz\", \"value\": \"qux\" },{ \"op\": \"test\", \"path\": \"/foo/1\", \"value\": 2 }]"},
{"{ \"baz\": \"qux\" }","[ { \"op\": \"test\", \"path\": \"/baz\", \"value\": \"bar\" }]"},
{"{ \"foo\": \"bar\" }","[{ \"op\": \"add\", \"path\": \"/child\", \"value\": { \"grandchild\": { } } }]"},
{"{ \"foo\": \"bar\" }","[{ \"op\": \"add\", \"path\": \"/baz\", \"value\": \"qux\", \"xyz\": 123 }]"},
{"{ \"foo\": \"bar\" }","[{ \"op\": \"add\", \"path\": \"/baz/bat\", \"value\": \"qux\" }]"},
{"{\"/\": 9,\"~1\": 10}","[{\"op\": \"test\", \"path\": \"/~01\", \"value\": 10}]"},
{"{\"/\": 9,\"~1\": 10}","[{\"op\": \"test\", \"path\": \"/~01\", \"value\": \"10\"}]"},
{"{ \"foo\": [\"bar\"] }","[ { \"op\": \"add\", \"path\": \"/foo/-\", \"value\": [\"abc\", \"def\"] }]"}};
// JSON Apply Patch tests:
const char *patches[15][3]={
{"{ \"foo\": \"bar\"}", "[{ \"op\": \"add\", \"path\": \"/baz\", \"value\": \"qux\" }]","{\"baz\": \"qux\",\"foo\": \"bar\"}"},
{"{ \"foo\": [ \"bar\", \"baz\" ] }", "[{ \"op\": \"add\", \"path\": \"/foo/1\", \"value\": \"qux\" }]","{\"foo\": [ \"bar\", \"qux\", \"baz\" ] }"},
{"{\"baz\": \"qux\",\"foo\": \"bar\"}"," [{ \"op\": \"remove\", \"path\": \"/baz\" }]","{\"foo\": \"bar\" }"},
{"{ \"foo\": [ \"bar\", \"qux\", \"baz\" ] }","[{ \"op\": \"remove\", \"path\": \"/foo/1\" }]","{\"foo\": [ \"bar\", \"baz\" ] }"},
{"{ \"baz\": \"qux\",\"foo\": \"bar\"}","[{ \"op\": \"replace\", \"path\": \"/baz\", \"value\": \"boo\" }]","{\"baz\": \"boo\",\"foo\": \"bar\"}"},
{"{\"foo\": {\"bar\": \"baz\",\"waldo\": \"fred\"},\"qux\": {\"corge\": \"grault\"}}","[{ \"op\": \"move\", \"from\": \"/foo/waldo\", \"path\": \"/qux/thud\" }]","{\"foo\": {\"bar\": \"baz\"},\"qux\": {\"corge\": \"grault\",\"thud\": \"fred\"}}"},
{"{ \"foo\": [ \"all\", \"grass\", \"cows\", \"eat\" ] }","[ { \"op\": \"move\", \"from\": \"/foo/1\", \"path\": \"/foo/3\" }]","{ \"foo\": [ \"all\", \"cows\", \"eat\", \"grass\" ] }"},
{"{\"baz\": \"qux\",\"foo\": [ \"a\", 2, \"c\" ]}","[{ \"op\": \"test\", \"path\": \"/baz\", \"value\": \"qux\" },{ \"op\": \"test\", \"path\": \"/foo/1\", \"value\": 2 }]",""},
{"{ \"baz\": \"qux\" }","[ { \"op\": \"test\", \"path\": \"/baz\", \"value\": \"bar\" }]",""},
{"{ \"foo\": \"bar\" }","[{ \"op\": \"add\", \"path\": \"/child\", \"value\": { \"grandchild\": { } } }]","{\"foo\": \"bar\",\"child\": {\"grandchild\": {}}}"},
{"{ \"foo\": \"bar\" }","[{ \"op\": \"add\", \"path\": \"/baz\", \"value\": \"qux\", \"xyz\": 123 }]","{\"foo\": \"bar\",\"baz\": \"qux\"}"},
{"{ \"foo\": \"bar\" }","[{ \"op\": \"add\", \"path\": \"/baz/bat\", \"value\": \"qux\" }]",""},
{"{\"/\": 9,\"~1\": 10}","[{\"op\": \"test\", \"path\": \"/~01\", \"value\": 10}]",""},
{"{\"/\": 9,\"~1\": 10}","[{\"op\": \"test\", \"path\": \"/~01\", \"value\": \"10\"}]",""},
{"{ \"foo\": [\"bar\"] }","[ { \"op\": \"add\", \"path\": \"/foo/-\", \"value\": [\"abc\", \"def\"] }]","{\"foo\": [\"bar\", [\"abc\", \"def\"]] }"}};
printf("JSON Patch Tests\n");
printf("JSON Apply Patch Tests\n");
for (int i=0;i<15;i++)
{
cJSON *object=cJSON_Parse(patches[i][0]);
@ -56,8 +57,31 @@ int main()
int err=cJSONUtils_ApplyPatches(object,patch);
char *output=cJSON_Print(object);
printf("Test %d (err %d):\n%s\n\n",i+1,err,output);
free(output);
free(output);cJSON_Delete(object);cJSON_Delete(patch);
}
// JSON Generate Patch tests:
printf("JSON Generate Patch Tests\n");
for (int i=0;i<15;i++)
{
if (!strlen(patches[i][2])) continue;
cJSON *from=cJSON_Parse(patches[i][0]);
cJSON *to=cJSON_Parse(patches[i][2]);
cJSON *patch=cJSONUtils_GeneratePatches(from,to);
char *out=cJSON_Print(patch);
printf("Test %d: (patch: %s):\n%s\n\n",i+1,patches[i][1],out);
free(out);cJSON_Delete(from);cJSON_Delete(to);cJSON_Delete(patch);
}
// Misc tests:
printf("JSON Pointer construct\n");
int numbers[10]={0,1,2,3,4,5,6,7,8,9};
cJSON *object=cJSON_CreateObject();
cJSON *nums=cJSON_CreateIntArray(numbers,10);
cJSON *num6=cJSON_GetArrayItem(nums,6);
cJSON_AddItemToObject(object,"numbers",nums);
printf("Pointer: [%s]\n",cJSONUtils_FindPointerFromObjectTo(object,num6));
printf("Pointer: [%s]\n",cJSONUtils_FindPointerFromObjectTo(object,nums));
printf("Pointer: [%s]\n",cJSONUtils_FindPointerFromObjectTo(object,object));
}