9dcd1235049ac0a119b69dae6ca06a46150c4301
[OpenSRF.git] / src / libopensrf / osrf_json_object.c
1 /*
2 Copyright (C) 2006  Georgia Public Library Service 
3 Bill Erickson <billserickson@gmail.com>
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14 */
15
16 #include <limits.h>
17 #include <opensrf/log.h>
18 #include <opensrf/osrf_json.h>
19 #include <opensrf/osrf_json_utils.h>
20
21 /* cleans up an object if it is morphing another object, also
22  * verifies that the appropriate storage container exists where appropriate */
23 #define JSON_INIT_CLEAR(_obj_, newtype)         \
24         if( _obj_->type == JSON_HASH && newtype != JSON_HASH ) {                        \
25                 osrfHashFree(_obj_->value.h);                   \
26                 _obj_->value.h = NULL;                                  \
27 } else if( _obj_->type == JSON_ARRAY && newtype != JSON_ARRAY ) {       \
28                 osrfListFree(_obj_->value.l);                   \
29                 _obj_->value.l = NULL;                                  \
30 } else if( _obj_->type == JSON_STRING && newtype != JSON_STRING ) { \
31                 free(_obj_->value.s);                                           \
32                 _obj_->value.s = NULL;                                  \
33 } \
34         _obj_->type = newtype;\
35         if( newtype == JSON_HASH && _obj_->value.h == NULL ) {  \
36                 _obj_->value.h = osrfNewHash();         \
37                 _obj_->value.h->freeItem = _jsonFreeHashItem; \
38 } else if( newtype == JSON_ARRAY && _obj_->value.l == NULL ) {  \
39                 _obj_->value.l = osrfNewList();         \
40                 _obj_->value.l->freeItem = _jsonFreeListItem;\
41 }
42
43 static int unusedObjCapture = 0;
44 static int unusedObjRelease = 0;
45 static int mallocObjCreate = 0;
46 static int currentListLen = 0;
47
48 union unusedObjUnion{
49
50         union unusedObjUnion* next;
51         jsonObject obj;
52 };
53 typedef union unusedObjUnion unusedObj;
54
55 // We maintain a free list of jsonObjects that are available
56 // for use, in order to reduce the churning through
57 // malloc() and free().
58
59 static unusedObj* freeObjList = NULL;
60
61 static void add_json_to_buffer( const jsonObject* obj, growing_buffer * buf );
62
63 /**
64  * Return all unused jsonObjects to the heap
65  * @return Nothing
66  */
67 void jsonObjectFreeUnused( void ) {
68
69         unusedObj* temp;
70         while( freeObjList ) {
71                 temp = freeObjList->next;
72                 free( freeObjList );
73                 freeObjList = temp;
74         }
75 }
76
77 jsonObject* jsonNewObject(const char* data) {
78
79         jsonObject* o;
80
81         if( freeObjList ) {
82                 o = (jsonObject*) freeObjList;
83                 freeObjList = freeObjList->next;
84         unusedObjRelease++;
85         currentListLen--;
86         } else {
87                 OSRF_MALLOC( o, sizeof(jsonObject) );
88         mallocObjCreate++;
89     }
90
91         o->size = 0;
92         o->classname = NULL;
93         o->parent = NULL;
94
95         if(data) {
96                 o->type = JSON_STRING;
97                 o->value.s = strdup(data);
98         } else {
99                 o->type = JSON_NULL;
100                 o->value.s = NULL;
101         }
102
103         return o;
104 }
105
106 jsonObject* jsonNewObjectFmt(const char* data, ...) {
107
108         jsonObject* o;
109
110         if( freeObjList ) {
111                 o = (jsonObject*) freeObjList;
112                 freeObjList = freeObjList->next;
113         unusedObjRelease++;
114         currentListLen--;
115         } else {
116                 OSRF_MALLOC( o, sizeof(jsonObject) );
117         mallocObjCreate++;
118     }
119
120         o->size = 0;
121         o->classname = NULL;
122         o->parent = NULL;
123
124         if(data) {
125                 VA_LIST_TO_STRING(data);
126                 o->type = JSON_STRING;
127                 o->value.s = strdup(VA_BUF);
128         }
129         else {
130                 o->type = JSON_NULL;
131                 o->value.s = NULL;
132         }
133         
134         return o;
135 }
136
137 jsonObject* jsonNewNumberObject( double num ) {
138         jsonObject* o = jsonNewObject(NULL);
139         o->type = JSON_NUMBER;
140         o->value.n = num;
141         return o;
142 }
143
144 jsonObject* jsonNewBoolObject(int val) {
145     jsonObject* o = jsonNewObject(NULL);
146     o->type = JSON_BOOL;
147     jsonSetBool(o, val);
148     return o;
149 }
150
151 jsonObject* jsonNewObjectType(int type) {
152         jsonObject* o = jsonNewObject(NULL);
153         o->type = type;
154         return o;
155 }
156
157 void jsonObjectFree( jsonObject* o ) {
158
159         if(!o || o->parent) return;
160         free(o->classname);
161
162         switch(o->type) {
163                 case JSON_HASH          : osrfHashFree(o->value.h); break;
164                 case JSON_ARRAY : osrfListFree(o->value.l); break;
165                 case JSON_STRING        : free(o->value.s); break;
166         }
167
168         // Stick the old jsonObject onto a free list
169         // for potential reuse
170         
171         unusedObj* unused = (unusedObj*) o;
172         unused->next = freeObjList;
173         freeObjList = unused;
174
175     unusedObjCapture++;
176     currentListLen++;
177     if (unusedObjCapture > 1 && !(unusedObjCapture % 1000))
178         osrfLogDebug( OSRF_LOG_MARK, "Objects malloc()'d: %d, Reusable objects captured: %d, Objects reused: %d, Current List Length: %d", mallocObjCreate, unusedObjCapture, unusedObjRelease, currentListLen );
179 }
180
181 static void _jsonFreeHashItem(char* key, void* item){
182         if(!item) return;
183         jsonObject* o = (jsonObject*) item;
184         o->parent = NULL; /* detach the item */
185         jsonObjectFree(o);
186 }
187 static void _jsonFreeListItem(void* item){
188         if(!item) return;
189         jsonObject* o = (jsonObject*) item;
190         o->parent = NULL; /* detach the item */
191         jsonObjectFree(o);
192 }
193
194 void jsonSetBool(jsonObject* bl, int val) {
195     if(!bl) return;
196     JSON_INIT_CLEAR(bl, JSON_BOOL);
197     bl->value.b = val;
198 }
199
200 unsigned long jsonObjectPush(jsonObject* o, jsonObject* newo) {
201     if(!o) return -1;
202     if(!newo) newo = jsonNewObject(NULL);
203         JSON_INIT_CLEAR(o, JSON_ARRAY);
204         newo->parent = o;
205         osrfListPush( o->value.l, newo );
206         o->size = o->value.l->size;
207         return o->size;
208 }
209
210 unsigned long jsonObjectSetIndex(jsonObject* dest, unsigned long index, jsonObject* newObj) {
211     if(!dest) return -1;
212     if(!newObj) newObj = jsonNewObject(NULL);
213         JSON_INIT_CLEAR(dest, JSON_ARRAY);
214         newObj->parent = dest;
215         osrfListSet( dest->value.l, newObj, index );
216         dest->size = dest->value.l->size;
217         return dest->value.l->size;
218 }
219
220 unsigned long jsonObjectSetKey( jsonObject* o, const char* key, jsonObject* newo) {
221     if(!o) return -1;
222     if(!newo) newo = jsonNewObject(NULL);
223         JSON_INIT_CLEAR(o, JSON_HASH);
224         newo->parent = o;
225         osrfHashSet( o->value.h, newo, key );
226         o->size = o->value.h->size;
227         return o->size;
228 }
229
230 jsonObject* jsonObjectGetKey( jsonObject* obj, const char* key ) {
231         if(!(obj && obj->type == JSON_HASH && obj->value.h && key)) return NULL;
232         return osrfHashGet( obj->value.h, key);
233 }
234
235 const jsonObject* jsonObjectGetKeyConst( const jsonObject* obj, const char* key ) {
236         if(!(obj && obj->type == JSON_HASH && obj->value.h && key)) return NULL;
237         return osrfHashGet( obj->value.h, key);
238 }
239
240 char* jsonObjectToJSON( const jsonObject* obj ) {
241         jsonObject* obj2 = jsonObjectEncodeClass( obj );
242         char* json = jsonObjectToJSONRaw(obj2);
243         jsonObjectFree(obj2);
244         return json;
245 }
246
247 char* jsonObjectToJSONRaw( const jsonObject* obj ) {
248         if(!obj) return NULL;
249         growing_buffer* buf = buffer_init(32);
250         add_json_to_buffer( obj, buf );
251         return buffer_release( buf );
252 }
253
254 static void add_json_to_buffer( const jsonObject* obj, growing_buffer * buf ) {
255
256         switch(obj->type) {
257
258                 case JSON_BOOL :
259                         if(obj->value.b) OSRF_BUFFER_ADD(buf, "true"); 
260                         else OSRF_BUFFER_ADD(buf, "false"); 
261                         break;
262
263                 case JSON_NUMBER: {
264                         double x = obj->value.n;
265                         if( x <= INT_MAX && x >= INT_MIN && x == (int) x ) {
266                                 INT_TO_STRING((int)x);
267                                 OSRF_BUFFER_ADD(buf, INTSTR);
268
269                         } else {
270                                 DOUBLE_TO_STRING(x);
271                                 OSRF_BUFFER_ADD(buf, DOUBLESTR);
272                         }
273                         break;
274                 }
275
276                 case JSON_NULL:
277                         OSRF_BUFFER_ADD(buf, "null");
278                         break;
279
280                 case JSON_STRING:
281                         OSRF_BUFFER_ADD_CHAR(buf, '"');
282                         char* data = obj->value.s;
283                         int len = strlen(data);
284                         
285                         char* output = uescape(data, len, 1);
286                         OSRF_BUFFER_ADD(buf, output);
287                         free(output);
288                         OSRF_BUFFER_ADD_CHAR(buf, '"');
289                         break;
290                         
291                 case JSON_ARRAY: {
292                         OSRF_BUFFER_ADD_CHAR(buf, '[');
293                         if( obj->value.l ) {
294                                 int i;
295                                 for( i = 0; i != obj->value.l->size; i++ ) {
296                                         if(i > 0) OSRF_BUFFER_ADD(buf, ",");
297                                         add_json_to_buffer( OSRF_LIST_GET_INDEX(obj->value.l, i), buf );
298                                 }
299                         }
300                         OSRF_BUFFER_ADD_CHAR(buf, ']');
301                         break;
302                 }
303
304                 case JSON_HASH: {
305
306                         OSRF_BUFFER_ADD_CHAR(buf, '{');
307                         osrfHashIterator* itr = osrfNewHashIterator(obj->value.h);
308                         jsonObject* item;
309                         int i = 0;
310
311                         while( (item = osrfHashIteratorNext(itr)) ) {
312                                 if(i++ > 0) OSRF_BUFFER_ADD(buf, ",");
313                                 buffer_fadd(buf, "\"%s\":", itr->current);
314                                 add_json_to_buffer( item, buf );
315                         }
316
317                         osrfHashIteratorFree(itr);
318                         OSRF_BUFFER_ADD_CHAR(buf, '}');
319                         break;
320                 }
321         }
322 }
323
324
325 jsonIterator* jsonNewIterator(const jsonObject* obj) {
326         if(!obj) return NULL;
327         jsonIterator* itr;
328         OSRF_MALLOC(itr, sizeof(jsonIterator));
329
330         itr->obj                = (jsonObject*) obj;
331         itr->index      = 0;
332         itr->key                = NULL;
333
334         if( obj->type == JSON_HASH )
335                 itr->hashItr = osrfNewHashIterator(obj->value.h);
336         
337         return itr;
338 }
339
340 void jsonIteratorFree(jsonIterator* itr) {
341         if(!itr) return;
342         free(itr->key);
343         osrfHashIteratorFree(itr->hashItr);
344         free(itr);
345 }
346
347 jsonObject* jsonIteratorNext(jsonIterator* itr) {
348         if(!(itr && itr->obj)) return NULL;
349         if( itr->obj->type == JSON_HASH ) {
350                 if(!itr->hashItr) return NULL;
351                 jsonObject* item = osrfHashIteratorNext(itr->hashItr);
352                 free(itr->key);
353                 itr->key = strdup(itr->hashItr->current);
354                 return item;
355         } else {
356                 return jsonObjectGetIndex( itr->obj, itr->index++ );
357         }
358 }
359
360 int jsonIteratorHasNext(const jsonIterator* itr) {
361         if(!(itr && itr->obj)) return 0;
362         if( itr->obj->type == JSON_HASH )
363                 return osrfHashIteratorHasNext( itr->hashItr );
364         return (itr->index < itr->obj->size) ? 1 : 0;
365 }
366
367 jsonObject* jsonObjectGetIndex( const jsonObject* obj, unsigned long index ) {
368         if(!obj) return NULL;
369         return (obj->type == JSON_ARRAY) ? 
370         (OSRF_LIST_GET_INDEX(obj->value.l, index)) : NULL;
371 }
372
373
374
375 unsigned long jsonObjectRemoveIndex(jsonObject* dest, unsigned long index) {
376         if( dest && dest->type == JSON_ARRAY ) {
377                 osrfListRemove(dest->value.l, index);
378                 return dest->value.l->size;
379         }
380         return -1;
381 }
382
383
384 unsigned long jsonObjectRemoveKey( jsonObject* dest, const char* key) {
385         if( dest && key && dest->type == JSON_HASH ) {
386                 osrfHashRemove(dest->value.h, key);
387                 return 1;
388         }
389         return -1;
390 }
391
392 char* jsonObjectGetString(const jsonObject* obj) {
393         return (obj && obj->type == JSON_STRING) ? obj->value.s : NULL;
394 }
395
396 double jsonObjectGetNumber( const jsonObject* obj ) {
397         return (obj && obj->type == JSON_NUMBER) ? obj->value.n : 0;
398 }
399
400 void jsonObjectSetString(jsonObject* dest, const char* string) {
401         if(!(dest && string)) return;
402         JSON_INIT_CLEAR(dest, JSON_STRING);
403         free(dest->value.s);
404         dest->value.s = strdup(string);
405 }
406
407 void jsonObjectSetNumber(jsonObject* dest, double num) {
408         if(!dest) return;
409         JSON_INIT_CLEAR(dest, JSON_NUMBER);
410         dest->value.n = num;
411 }
412
413 void jsonObjectSetClass(jsonObject* dest, const char* classname ) {
414         if(!(dest && classname)) return;
415         free(dest->classname);
416         dest->classname = strdup(classname);
417 }
418 const char* jsonObjectGetClass(const jsonObject* dest) {
419     if(!dest) return NULL;
420     return dest->classname;
421 }
422
423 jsonObject* jsonObjectClone( const jsonObject* o ) {
424     if(!o) return jsonNewObject(NULL);
425
426     int i;
427     jsonObject* arr; 
428     jsonObject* hash; 
429     jsonIterator* itr;
430     jsonObject* tmp;
431     jsonObject* result = NULL;
432
433     switch(o->type) {
434         case JSON_NULL:
435             result = jsonNewObject(NULL);
436             break;
437         case JSON_STRING:
438             result = jsonNewObject(jsonObjectGetString(o));
439             break;
440         case JSON_NUMBER:
441             result = jsonNewNumberObject(jsonObjectGetNumber(o));
442             break;
443         case JSON_BOOL:
444             result = jsonNewBoolObject(jsonBoolIsTrue((jsonObject*) o));
445             break;
446         case JSON_ARRAY:
447             arr = jsonNewObject(NULL);
448             arr->type = JSON_ARRAY;
449             for(i=0; i < o->size; i++) 
450                 jsonObjectPush(arr, jsonObjectClone(jsonObjectGetIndex(o, i)));
451             result = arr;
452             break;
453         case JSON_HASH:
454             hash = jsonNewObject(NULL);
455             hash->type = JSON_HASH;
456             itr = jsonNewIterator(o);
457             while( (tmp = jsonIteratorNext(itr)) )
458                 jsonObjectSetKey(hash, itr->key, jsonObjectClone(tmp));
459             jsonIteratorFree(itr);
460             result = hash;
461             break;
462     }
463
464     jsonObjectSetClass(result, jsonObjectGetClass(o));
465     return result;
466 }
467
468 int jsonBoolIsTrue( const jsonObject* boolObj ) {
469     if( boolObj && boolObj->type == JSON_BOOL && boolObj->value.b )
470         return 1;
471     return 0;
472 }
473
474
475 char* jsonObjectToSimpleString( const jsonObject* o ) {
476         if(!o) return NULL;
477
478         char* value = NULL;
479
480         switch( o->type ) {
481
482                 case JSON_NUMBER: {
483
484                         if( o->value.n == (int) o->value.n ) {
485                                 INT_TO_STRING((int) o->value.n);        
486                                 value = strdup(INTSTR);
487
488                         } else {
489                                 DOUBLE_TO_STRING(o->value.n);
490                                 value = strdup(DOUBLESTR);
491                         }
492
493                         break;
494                 }
495
496                 case JSON_STRING:
497                         value = strdup(o->value.s);
498         }
499
500         return value;
501 }
502
503