libcm is a C development framework with an emphasis on audio signal processing applications.
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

cmJson.h 27KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504
  1. #ifndef cmJson_h
  2. #define cmJson_h
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  6. //{
  7. //(
  8. //
  9. // Limitations:
  10. //
  11. // 1. Accpets two digit hex sequences with
  12. // the \\u escape command. JSON specifies 4 digits.
  13. //
  14. // 2. The scientific notation for real numbers is limited to
  15. // exponent prefixes: e,E,e-,E-. The prefixes e+ and E+ are
  16. // not recognized by cmLex.
  17. //
  18. // Extensions:
  19. //
  20. // 1. Will accept C style identifiers where JSON demands
  21. // quoted strings.
  22. //
  23. // 2. Will accept C style hex notation (0xddd) for integer values.
  24. //
  25. //)
  26. //(
  27. // JSON data type flags
  28. enum
  29. {
  30. kInvalidTId = 0x0000,
  31. kObjectTId = 0x0001, // children are pairs
  32. kPairTId = 0x0002, // children are string : value pairs
  33. kArrayTId = 0x0004, // children may be of any type
  34. kStringTId = 0x0008, // terminal
  35. kNullTId = 0x0040, // terminal
  36. kIntTId = 0x0010, // terminal
  37. kRealTId = 0x0020, // terminal
  38. kTrueTId = 0x0080, // terminal
  39. kFalseTId = 0x0100, // terminal
  40. kMaskTId = 0x01ff,
  41. kOptArgJsFl = 0x0800, // only used by cmJsonVMemberValues()
  42. kTempJsFl = 0x1000, // used internally
  43. kNumericTId = kIntTId | kRealTId | kTrueTId | kFalseTId,
  44. kBoolTId = kTrueTId | kFalseTId
  45. };
  46. enum
  47. {
  48. kOkJsRC,
  49. kMemAllocErrJsRC,
  50. kLexErrJsRC,
  51. kSyntaxErrJsRC,
  52. kFileOpenErrJsRC,
  53. kFileCreateErrJsRC,
  54. kFileReadErrJsRC,
  55. kFileSeekErrJsRC,
  56. kFileCloseErrJsRC,
  57. kInvalidHexEscapeJsRC,
  58. kSerialErrJsRC,
  59. kNodeNotFoundJsRC,
  60. kNodeCannotCvtJsRC,
  61. kCannotRemoveLabelJsRC,
  62. kInvalidNodeTypeJsRC,
  63. kValidateFailJsRC,
  64. kCsvErrJsRC,
  65. kBufTooSmallJsRC
  66. };
  67. typedef unsigned cmJsRC_t;
  68. typedef cmHandle_t cmJsonH_t;
  69. // JSON tree node
  70. typedef struct cmJsonNode_str
  71. {
  72. unsigned typeId; // id of this node
  73. struct cmJsonNode_str* siblingPtr; // next ele in array or member list
  74. struct cmJsonNode_str* ownerPtr; // parent node ptr
  75. union
  76. {
  77. // childPtr usage:
  78. // object: first pair
  79. // array: first element
  80. // pair: string
  81. struct cmJsonNode_str* childPtr;
  82. int intVal; // valid if typeId == kIntTId
  83. double realVal; // valid if typeId == kRealTId
  84. char* stringVal; // valid if typeId == kStringTId
  85. bool boolVal; // valid if typeId == kTrueTId || kFalseTId
  86. } u;
  87. } cmJsonNode_t;
  88. extern cmJsonH_t cmJsonNullHandle;
  89. // Initialize a json parser/tree object
  90. cmJsRC_t cmJsonInitialize( cmJsonH_t* hp, cmCtx_t* ctx );
  91. // Equivalent to cmJsonInitialize() followed by cmJsonParseFile()
  92. cmJsRC_t cmJsonInitializeFromFile( cmJsonH_t* hp, const char* fn, cmCtx_t* ctx );
  93. // Equivalent to cmJsonInitialize() followed by cmJsonParse(h,buf,cnt,NULL).
  94. cmJsRC_t cmJsonInitializeFromBuf( cmJsonH_t* hp, cmCtx_t* ctx, const char* buf, unsigned bufByteCnt );
  95. // Release all the resources held by the tree.
  96. cmJsRC_t cmJsonFinalize( cmJsonH_t* hp );
  97. // Returns true if 'h' is a valid cmJsonH_t handle.
  98. bool cmJsonIsValid( cmJsonH_t h );
  99. // Build the internal tree by parsing a text buffer.
  100. // altRootPtr is an optional alternate root ptr which can be used
  101. // append to an existing tree. Set to altRootPtr to
  102. // NULL to append the tree to the internal root.
  103. // If altRootPtr is given it must point ot either an array or
  104. // object node.
  105. cmJsRC_t cmJsonParse( cmJsonH_t h, const char* buf, unsigned bufCharCnt, cmJsonNode_t* altRootPtr );
  106. // Fills a text buffer from a file and calls cmJsonParse().
  107. cmJsRC_t cmJsonParseFile( cmJsonH_t h, const char* fn, cmJsonNode_t* altRootPtr );
  108. // Return the root node of the internal tree.
  109. cmJsonNode_t* cmJsonRoot( cmJsonH_t h );
  110. // Return the tree to the post initialize state by clearing the internal tree.
  111. cmJsRC_t cmJsonClearTree( cmJsonH_t h );
  112. // Node type predicates.
  113. bool cmJsonIsObject( const cmJsonNode_t* np );
  114. bool cmJsonIsArray( const cmJsonNode_t* np );
  115. bool cmJsonIsPair( const cmJsonNode_t* np );
  116. bool cmJsonIsString( const cmJsonNode_t* np );
  117. bool cmJsonIsInt( const cmJsonNode_t* np );
  118. bool cmJsonIsReal( const cmJsonNode_t* np );
  119. bool cmJsonIsBool( const cmJsonNode_t* np );
  120. // Return the count of child nodes of 'np'.
  121. // Note that only object,array, and pair nodes have children.
  122. unsigned cmJsonChildCount( const cmJsonNode_t* np );
  123. // Return the node at 'index' from an element array.
  124. // 'np must point to an array element.
  125. cmJsonNode_t* cmJsonArrayElement( cmJsonNode_t* np, unsigned index );
  126. const cmJsonNode_t* cmJsonArrayElementC( const cmJsonNode_t* np, unsigned index );
  127. // Return the child value node of a pair with a label node equal to 'label'.
  128. // Set 'root' to NULL to begin the search at the internal tree root node.
  129. // Set 'typeIdMask' with all type flags to match.
  130. // If 'typeIdMask' is equal to kInvalidTId then all types will match.
  131. cmJsonNode_t* cmJsonFindValue( cmJsonH_t h, const char* label, const cmJsonNode_t* root, unsigned typeIdMask );
  132. // Return the value node of a pair at the end of an object path.
  133. // 'path' is a '/' seperated list of object names where the final
  134. // object specifies the pair label for the value to return.
  135. const cmJsonNode_t* cmJsonFindPathValueC( cmJsonH_t h, const char* path, const cmJsonNode_t* root, unsigned typeIdMask );
  136. cmJsonNode_t* cmJsonFindPathValue( cmJsonH_t h, const char* path, const cmJsonNode_t* root, unsigned typeIdMask );
  137. // Return the node value. If 'np' does not point to the same type as
  138. // specified in '*retPtr' then the value is converted if possible.
  139. // If the value cannot be converted function returns a 'kNodeCannotCvtJsRC'
  140. // error
  141. cmJsRC_t cmJsonUIntValue( const cmJsonNode_t* np, unsigned* retPtr );
  142. cmJsRC_t cmJsonIntValue( const cmJsonNode_t* np, int* retPtr );
  143. cmJsRC_t cmJsonRealValue( const cmJsonNode_t* np, double* retPtr );
  144. cmJsRC_t cmJsonBoolValue( const cmJsonNode_t* np, bool* retPtr );
  145. cmJsRC_t cmJsonStringValue( const cmJsonNode_t* np, const char ** retPtrPtr );
  146. cmJsRC_t cmJsonPairNode( const cmJsonNode_t* vp, cmJsonNode_t ** retPtrPtr );
  147. cmJsRC_t cmJsonArrayNode( const cmJsonNode_t* vp, cmJsonNode_t ** retPtrPtr );
  148. cmJsRC_t cmJsonObjectNode( const cmJsonNode_t* vp, cmJsonNode_t ** retPtrPtr );
  149. // Return the label from a pair object.
  150. const char* cmJsonPairLabel( const cmJsonNode_t* pairPtr );
  151. unsigned cmJsonPairTypeId( const cmJsonNode_t* pairPtr );
  152. cmJsonNode_t* cmJsonPairValue( cmJsonNode_t* pairPtr );
  153. // Return values associated with the member values in the object
  154. // pointed to by object objectNodePtr.
  155. cmJsRC_t cmJsonUIntMember( const cmJsonNode_t* objectNodePtr, const char* label, unsigned* retPtr );
  156. cmJsRC_t cmJsonIntMember( const cmJsonNode_t* objectNodePtr, const char* label, int* retPtr );
  157. cmJsRC_t cmJsonRealMember( const cmJsonNode_t* objectNodePtr, const char* label, double* retPtr );
  158. cmJsRC_t cmJsonBoolMember( const cmJsonNode_t* objectNodePtr, const char* label, bool* retPtr );
  159. cmJsRC_t cmJsonStringMember( const cmJsonNode_t* objectNodePtr, const char* label, const char** retPtrPtr );
  160. // Returns array or object nodes.
  161. cmJsRC_t cmJsonNodeMember( const cmJsonNode_t* objectNodePtr, const char* label, cmJsonNode_t** nodePtrPtr );
  162. // Returns the value of the member pair named by 'label' or NULL if the
  163. // named pair does not exist.
  164. cmJsonNode_t* cmJsonNodeMemberValue( const cmJsonNode_t* np, const char* label );
  165. // Return values for specified pairs from an object node.
  166. //
  167. // The var args syntax is: <label>,<typeId>,<valuePtr>.
  168. // This functionis implemented in terms of cmJsonXXXMember().
  169. //
  170. // Add kOptArgJsFl to <typeId> if the member may not exist in
  171. // the object - otherwise the function will fail with a
  172. // kNodeNotFoundJsRC error and errLabelPtr will have the name of the missing pair.
  173. //
  174. // Terminate the var args list with NULL.
  175. //
  176. // Object,Array, and Pair members are returned as node pointers.
  177. //
  178. // Since kBoolTId does not exist use kTrueTId or kFalseTId to
  179. // return bool values.
  180. cmJsRC_t cmJsonVMemberValues(const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, va_list vl );
  181. cmJsRC_t cmJsonMemberValues( const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, ... );
  182. // If objectNodePtr is set to NULL then the tree root is used as the base for the search.
  183. // pathPrefix may be set to NULL.
  184. cmJsRC_t cmJsonPathToValueNode( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, const cmJsonNode_t** nodePtrPtr );
  185. cmJsRC_t cmJsonPathToBool( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, bool* retValPtr );
  186. cmJsRC_t cmJsonPathToInt( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, int* retValPtr );
  187. cmJsRC_t cmJsonPathToUInt( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, unsigned* retValPtr );
  188. cmJsRC_t cmJsonPathToReal( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, double* retValPtr );
  189. cmJsRC_t cmJsonPathToString( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, const char** retValPtr );
  190. cmJsRC_t cmJsonPathToPair( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, cmJsonNode_t** retValPtr );
  191. cmJsRC_t cmJsonPathToArray( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, cmJsonNode_t** retValPtr );
  192. cmJsRC_t cmJsonPathToObject( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, cmJsonNode_t** retValPtr );
  193. // Same as cmJsonMemberValues() except labels may be paths to a given variable.
  194. // These paths are equivalent to those used in cmJsonFindPathValue()
  195. // If objectNodePtr is NULL then the JSON tree root is used as the
  196. // base reference object.
  197. // If pathPrefix is non-NULL then it is appended to each of the
  198. // individual paths.
  199. cmJsRC_t cmJsonVPathValues(cmJsonH_t h, const char* pathPrefix, const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, va_list vl );
  200. cmJsRC_t cmJsonPathValues( cmJsonH_t h, const char* pathPrefix, const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, ... );
  201. // Set 'typeId' to the type of the new node.
  202. // Use 'intVal' for the value of int nodes.
  203. // Use 'realVal' for the value of real nodes.
  204. // Use 'stringVal' for the label of pairs and the value of string nodes.
  205. // 'retNodePtrPtr' is optional
  206. cmJsRC_t cmJsonCreate( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned typeId, const char* stringVal, int intVal, double realVal, cmJsonNode_t** newNodePtrPtr );
  207. // Insert new nodes in the tree. If the tree is empty then the first
  208. // inserted node will become the root (this must be an object or array node.).
  209. cmJsonNode_t* cmJsonCreateObject( cmJsonH_t h, cmJsonNode_t* parentPtr );
  210. cmJsonNode_t* cmJsonCreateArray( cmJsonH_t h, cmJsonNode_t* parentPtr );
  211. cmJsonNode_t* cmJsonCreatePair( cmJsonH_t h, cmJsonNode_t* parentPtr, const char* label );
  212. cmJsRC_t cmJsonCreateString( cmJsonH_t h, cmJsonNode_t* parentPtr, const char* stringValue );
  213. cmJsRC_t cmJsonCreateStringN(cmJsonH_t h, cmJsonNode_t* parentPtr, const char* stringValue, unsigned stringCharCnt );
  214. cmJsRC_t cmJsonCreateInt( cmJsonH_t h, cmJsonNode_t* parentPtr, int value );
  215. cmJsRC_t cmJsonCreateReal( cmJsonH_t h, cmJsonNode_t* parentPtr, double value );
  216. cmJsRC_t cmJsonCreateBool( cmJsonH_t h, cmJsonNode_t* parentPtr, bool value );
  217. cmJsRC_t cmJsonCreateNull( cmJsonH_t h, cmJsonNode_t* parentPtr );
  218. cmJsRC_t cmJsonCreateStringArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const char** values );
  219. cmJsRC_t cmJsonCreateIntArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const int* values );
  220. cmJsRC_t cmJsonCreateRealArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const double* values );
  221. cmJsRC_t cmJsonCreateBoolArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const bool* values );
  222. //--------------------------------------------------------------------------------------------------------------
  223. //
  224. // Tree creation helper functiosn
  225. //
  226. cmJsRC_t cmJsonSetInt( cmJsonH_t h, cmJsonNode_t* np, int ival );
  227. cmJsRC_t cmJsonSetReal( cmJsonH_t h, cmJsonNode_t * np, double rval );
  228. cmJsRC_t cmJsonSetBool( cmJsonH_t h, cmJsonNode_t * np, bool bval );
  229. cmJsRC_t cmJsonSetString( cmJsonH_t h, cmJsonNode_t* np, const char* sval );
  230. // Insert a pair with a value indicated by 'typeId'.
  231. // 'stringVal','intVal' and 'realVal' are used as in cmJsonCreate().
  232. // Return a pointer to the new pair.
  233. cmJsonNode_t* cmJsonInsertPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned typeId, const char* stringVal, int intVal, double realVal );
  234. // Create a pair node and the associated label and value nodes and insert the pair in a parent object.
  235. // The object,array and pair creation functions return pointers to the pair value node.
  236. // These are helper functions that are implemented in terms of cmJsonCreateXXX() function.
  237. cmJsonNode_t* cmJsonInsertPairObject( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label );
  238. cmJsonNode_t* cmJsonInsertPairArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label );
  239. cmJsonNode_t* cmJsonInsertPairPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, const char* pairLabel );
  240. cmJsRC_t cmJsonInsertPairInt( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, int intVal );
  241. cmJsRC_t cmJsonInsertPairReal( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, double realVal );
  242. cmJsRC_t cmJsonInsertPairString( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, const char* string );
  243. cmJsRC_t cmJsonInsertPairStringN(cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, const char* string, unsigned stringCharCnt );
  244. cmJsRC_t cmJsonInsertPairBool( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, bool boolVal );
  245. cmJsRC_t cmJsonInsertPairNull( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label );
  246. cmJsRC_t cmJsonInsertPairIntArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const int* values );
  247. cmJsRC_t cmJsonInsertPairRealArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const double* values );
  248. cmJsRC_t cmJsonInsertPairStringArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const char** values );
  249. cmJsRC_t cmJsonInsertPairBoolArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const bool* values );
  250. // Returns pair pointer
  251. cmJsonNode_t* cmJsonInsertPairIntArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const int* values );
  252. cmJsonNode_t* cmJsonInsertPairRealArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const double* values );
  253. cmJsonNode_t* cmJsonInsertPairStringArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const char** values );
  254. cmJsonNode_t* cmJsonInsertPairBoolArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const bool* values );
  255. // Insert a pair (same as cmJsonInsertPair()) or if a pair
  256. // with a matching label/type already exists then replace the
  257. // existing value with a the new value.
  258. //
  259. // Set matchTypeMask with the type id's of all pair value types
  260. // which sould be considered a match. If matchTypeMask is set to
  261. // kInvalidTId then all value types will match.
  262. //
  263. // Return a pointer to the new or existing pair.
  264. //
  265. // When newTypeId == kObjectTId or kArrayTId then 'nv' may optionally be set to an object or array
  266. // to be set as the new value node for the selected pair. If 'nv' is NULL then an empty array or
  267. // object is created as the pair value node.
  268. //
  269. // When newTypeId == kPairTId then we are inserting/replacing a pair as the value of the selected pair.
  270. // In this case sv must be set to the new pair label. 'nv' may be optionally
  271. // set to a new pair value node. If 'nv' is NULL then the the new pair will have a value of type kNullTId
  272. cmJsonNode_t* cmJsonInsertOrReplacePair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, unsigned newTypeId, const char* sv, int iv, double dv, cmJsonNode_t* nv );
  273. // Returns pointer to object node.
  274. cmJsonNode_t* cmJsonInsertOrReplacePairObject( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newObjNodePtr );
  275. // Returns pointer to array node.
  276. cmJsonNode_t* cmJsonInsertOrReplacePairArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newArrayNodePtr );
  277. // Returns pointer to child pair node
  278. cmJsonNode_t* cmJsonInsertOrReplacePairPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* newPairLabel, cmJsonNode_t* newPairValNodePtr );
  279. cmJsRC_t cmJsonInsertOrReplacePairInt( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, int intVal );
  280. cmJsRC_t cmJsonInsertOrReplacePairReal( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, double realVal );
  281. cmJsRC_t cmJsonInsertOrReplacePairString( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* string );
  282. cmJsRC_t cmJsonInsertOrReplacePairBool( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, bool boolVal );
  283. cmJsRC_t cmJsonInsertOrReplacePairNull( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask );
  284. // Same as the above cmJsonInsertOrReplaceXXX() functions except
  285. // the function fails if a matching pair is not found.
  286. //
  287. // Replace a pair with the same name/type and return a pointer to the
  288. // effected pair. If a pair with the same name and type are not
  289. // found then no change is made and the function returns NULL.
  290. // For newTypeId=kObjectTId,kArrayTId,kPairTId the replaced pair node is blank,
  291. // in other words it will have no child nodes.
  292. cmJsonNode_t* cmJsonReplacePair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, unsigned newTypeId, const char* sv, int iv, double dv, cmJsonNode_t* nv );
  293. // Returns pointer to object node.
  294. cmJsonNode_t* cmJsonReplacePairObject( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newObjNodePtr );
  295. // Return pointer to array node.
  296. cmJsonNode_t* cmJsonReplacePairArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newArrayNodePtr );
  297. // Returns pointer to child pair node.
  298. cmJsonNode_t* cmJsonReplacePairPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* newPairLabel, cmJsonNode_t* newPairValueNodePtr );
  299. cmJsRC_t cmJsonReplacePairInt( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, int intVal );
  300. cmJsRC_t cmJsonReplacePairReal( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, double realVal );
  301. cmJsRC_t cmJsonReplacePairString( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* string );
  302. cmJsRC_t cmJsonReplacePairBool( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, bool boolVal );
  303. cmJsRC_t cmJsonReplacePairNull( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask );
  304. // Insert multiple pairs in a parent object. Terminate the pair sets with NULL.
  305. // Note that pair,int,real,bool, and string pairs are specified with 3 args: <label>,<typeId>,<value>
  306. // all others are specified with 2 args: <label>,<typeId>.
  307. // The last argument in this function must always be NULL.
  308. cmJsRC_t cmJsonVInsertPairs( cmJsonH_t h, cmJsonNode_t* objectNodePtr, va_list vl );
  309. cmJsRC_t cmJsonInsertPairs( cmJsonH_t h, cmJsonNode_t* objectNodePtr, ... );
  310. // Create an object node, fill it with the specified pairs, and return a pointer to
  311. // the new object node.
  312. // This function uses same var args syntax as cmJsonInsertPairs()
  313. cmJsonNode_t* cmJsonVCreateFilledObject( cmJsonH_t h, cmJsonNode_t* parentPtr, va_list vl );
  314. cmJsonNode_t* cmJsonCreateFilledObject( cmJsonH_t h, cmJsonNode_t* parentPtr, ... );
  315. //--------------------------------------------------------------------------------------------------------------
  316. // Remove a node from the tree by unlinking it from its
  317. // parent and siblings.
  318. // Set the freeFl to true if the node memory should also
  319. // be released.
  320. //
  321. // If 'freeFl' is false then np->ownerPtr and
  322. // np->siblingPtr remain valid when the function returns.
  323. // Even with the valid pointer however be careful
  324. // not to use the node in a way that it depends
  325. // on existing in the tree since the parent and
  326. // siblings will no longer know about it.
  327. //
  328. // If np is the root then the internal tree will be
  329. // cleared (i.e. cmJsonRoot(h) == NULL).
  330. //
  331. // This function will fail if 'np' points to the label value
  332. // of a pair node. Pair labels cannot be removed because this
  333. // would result in an invalid tree (all pairs must have two
  334. // child nodes where the first node is a string value). If 'np'
  335. // points to a pair value node then the value node is replaced
  336. // with a null node to maintain a valid pair structure.
  337. cmJsRC_t cmJsonRemoveNode( cmJsonH_t h, cmJsonNode_t* np, bool freeFl );
  338. //--------------------------------------------------------------------------------------------------------------
  339. // Duplicate the subtree pointed to by 'np' and attach it as a child
  340. // of the node pointed to by 'parentPtr'. This function performs a
  341. // deep copy of the subtree pointed to by np and returns the pointer
  342. // to the duplicated subtree.
  343. //
  344. // 'parentPtr' must be a legal parent for the sub-tree or NULL to not
  345. // attach the duplicate tree to any parent.
  346. //
  347. // The returned value is a pointer to the new subtree.
  348. //
  349. // If an error occurs the return value is NULL and cmJsonErrorCode()
  350. // can be used to obtain the code associated with the error.
  351. cmJsonNode_t* cmJsonDuplicateNode( cmJsonH_t h, const cmJsonNode_t* np, cmJsonNode_t* parentPtr );
  352. //--------------------------------------------------------------------------------------------------------------
  353. // Copy any pairs not found in the destintaion object from the
  354. // source object.
  355. // If an error occurs during merging the destination object is
  356. // returned unmodified. The most likely cause of an error is a
  357. // destination pair with the same name but different type
  358. // than a source pair.
  359. cmJsRC_t cmJsonMergeObjectNodes( cmJsonH_t h, cmJsonNode_t* destObjNodePtr, const cmJsonNode_t* srcObjNodePtr );
  360. //--------------------------------------------------------------------------------------------------------------
  361. // Validate the tree.
  362. cmJsRC_t cmJsonValidateTree( cmJsonH_t h );
  363. // Validate the tree beginning with np. Note that this function does
  364. // not print an error on failure but simply returns kValidateFailJsRC.
  365. cmJsRC_t cmJsonValidate( const cmJsonNode_t* np );
  366. // Get the count of bytes required to serialize the tree rooted at 'np'.
  367. unsigned cmJsonSerialByteCount( const cmJsonNode_t* np );
  368. // Serialize the tree rooted at 'np' into the buffer buf[bufByteCnt].
  369. cmJsRC_t cmJsonSerialize( const cmJsonNode_t* np, void* buf, unsigned bufByteCnt );
  370. // Serialize the subtree indicated by 'np' or the entire tree
  371. // if 'np' is NULL. The buffer created by this call will exist
  372. // for the life of 'h' or until the next call to cmJsonSerialize().
  373. // This function is implemented in terms of cmJsonSerialByteCount()
  374. // and cmJsonSerializeTree().
  375. cmJsRC_t cmJsonSerializeTree( cmJsonH_t h, const cmJsonNode_t* np, void** bufPtrPtr, unsigned* bufByteCntPtr);
  376. // Recreate the objects previously serialzed via cmJsonSerialize().
  377. // The tree held in the buffer will be reconstructed as a child of
  378. // altRootPtr (if it is non-NULL) or the internal root.
  379. // If altRootPtr is given then it must point to an array
  380. // or object node.
  381. cmJsRC_t cmJsonDeserialize( cmJsonH_t h, const void* bufPtr, cmJsonNode_t* altRootPtr );
  382. // Return a string/int/real/null/bool node as a string value.
  383. cmJsRC_t cmJsonLeafToString( const cmJsonNode_t* np, cmChar_t* buf, unsigned bufCharCnt );
  384. // Given a CSV file convert it to an array of JSON objects.
  385. // The first line of the CSV file must contain a comma seperated lists of types.
  386. // The type labels must be from the set: 'int','real','string','true','false'.
  387. // Note that either 'true' or 'false' can be use for boolean columns.
  388. // The seocnd line contains the field names as comma separated quoted strings.
  389. // For example "column1","column2","column3"
  390. // The data is presented as comma separated fields.
  391. // If parentNodePtr is NULL then the array will be created unattached to
  392. // the tree.
  393. // if arrayNodePtrPtr is non-NULL then the array node ptr will be returned.
  394. cmJsRC_t cmJsonFromCSV( cmJsonH_t h, const char* iFn, cmJsonNode_t* parentPtr, cmJsonNode_t** arrayNodePtrPtr );
  395. // Write a CSV file from an array of objects.
  396. // arrayNodePtr must point to an array of objects.
  397. cmJsRC_t cmJsonToCSV( cmJsonH_t h, const char* oFn, const cmJsonNode_t* arrayNodePtr );
  398. // Print the subtree using 'np as the root.
  399. void cmJsonPrintTree( const cmJsonNode_t* np, cmRpt_t* rpt );
  400. // Print the subtree using 'np' as the root to a file.
  401. // 'np' is optional and defaults to cmJsonRoot().
  402. cmJsRC_t cmJsonWrite( cmJsonH_t h, const cmJsonNode_t* np, const cmChar_t* fn );
  403. // Return the code of the last error generated. This is useful for the
  404. // the cmJsonCreateXXX() functions which do not return error codes but
  405. // may still fail.
  406. cmJsRC_t cmJsonErrorCode( cmJsonH_t h );
  407. void cmJsonClearErrorCode( cmJsonH_t h );
  408. // Validate the tree and print all the nodes.
  409. cmJsRC_t cmJsonReport( cmJsonH_t h );
  410. // Testing stub.
  411. cmJsRC_t cmJsonTest( const char* fn, cmCtx_t* ctx );
  412. //)
  413. //}
  414. #ifdef __cplusplus
  415. }
  416. #endif
  417. #endif