libcm is a C development framework with an emphasis on audio signal processing applications.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

cmJson.h 27KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510
  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. // Returns true if the tree has been modified since it was initialized.
  100. // If changes to the tree are done directly on the nodes, rather than using
  101. // the API functions, then this function may not indicate the actual
  102. // modification state of the tree.
  103. bool cmJsonIsModified( cmJsonH_t h );
  104. // Build the internal tree by parsing a text buffer.
  105. // altRootPtr is an optional alternate root ptr which can be used
  106. // append to an existing tree. Set to altRootPtr to
  107. // NULL to append the tree to the internal root.
  108. // If altRootPtr is given it must point ot either an array or
  109. // object node.
  110. cmJsRC_t cmJsonParse( cmJsonH_t h, const char* buf, unsigned bufCharCnt, cmJsonNode_t* altRootPtr );
  111. // Fills a text buffer from a file and calls cmJsonParse().
  112. cmJsRC_t cmJsonParseFile( cmJsonH_t h, const char* fn, cmJsonNode_t* altRootPtr );
  113. // Return the root node of the internal tree.
  114. cmJsonNode_t* cmJsonRoot( cmJsonH_t h );
  115. // Return the tree to the post initialize state by clearing the internal tree.
  116. cmJsRC_t cmJsonClearTree( cmJsonH_t h );
  117. // Node type predicates.
  118. bool cmJsonIsObject( const cmJsonNode_t* np );
  119. bool cmJsonIsArray( const cmJsonNode_t* np );
  120. bool cmJsonIsPair( const cmJsonNode_t* np );
  121. bool cmJsonIsString( const cmJsonNode_t* np );
  122. bool cmJsonIsInt( const cmJsonNode_t* np );
  123. bool cmJsonIsReal( const cmJsonNode_t* np );
  124. bool cmJsonIsBool( const cmJsonNode_t* np );
  125. // Return the count of child nodes of 'np'.
  126. // Note that only object,array, and pair nodes have children.
  127. unsigned cmJsonChildCount( const cmJsonNode_t* np );
  128. // Return the node at 'index' from an element array.
  129. // 'np must point to an array element.
  130. cmJsonNode_t* cmJsonArrayElement( cmJsonNode_t* np, unsigned index );
  131. const cmJsonNode_t* cmJsonArrayElementC( const cmJsonNode_t* np, unsigned index );
  132. // Return the child value node of a pair with a label node equal to 'label'.
  133. // Set 'root' to NULL to begin the search at the internal tree root node.
  134. // Set 'typeIdMask' with all type flags to match.
  135. // If 'typeIdMask' is equal to kInvalidTId then all types will match.
  136. cmJsonNode_t* cmJsonFindValue( cmJsonH_t h, const char* label, const cmJsonNode_t* root, unsigned typeIdMask );
  137. // Return the value node of a pair at the end of an object path.
  138. // 'path' is a '/' seperated list of object names where the final
  139. // object specifies the pair label for the value to return.
  140. const cmJsonNode_t* cmJsonFindPathValueC( cmJsonH_t h, const char* path, const cmJsonNode_t* root, unsigned typeIdMask );
  141. cmJsonNode_t* cmJsonFindPathValue( cmJsonH_t h, const char* path, const cmJsonNode_t* root, unsigned typeIdMask );
  142. // Return the node value. If 'np' does not point to the same type as
  143. // specified in '*retPtr' then the value is converted if possible.
  144. // If the value cannot be converted function returns a 'kNodeCannotCvtJsRC'
  145. // error
  146. cmJsRC_t cmJsonUIntValue( const cmJsonNode_t* np, unsigned* retPtr );
  147. cmJsRC_t cmJsonIntValue( const cmJsonNode_t* np, int* retPtr );
  148. cmJsRC_t cmJsonRealValue( const cmJsonNode_t* np, double* retPtr );
  149. cmJsRC_t cmJsonBoolValue( const cmJsonNode_t* np, bool* retPtr );
  150. cmJsRC_t cmJsonStringValue( const cmJsonNode_t* np, const char ** retPtrPtr );
  151. cmJsRC_t cmJsonPairNode( const cmJsonNode_t* vp, cmJsonNode_t ** retPtrPtr );
  152. cmJsRC_t cmJsonArrayNode( const cmJsonNode_t* vp, cmJsonNode_t ** retPtrPtr );
  153. cmJsRC_t cmJsonObjectNode( const cmJsonNode_t* vp, cmJsonNode_t ** retPtrPtr );
  154. // Return the label from a pair object.
  155. const char* cmJsonPairLabel( const cmJsonNode_t* pairPtr );
  156. unsigned cmJsonPairTypeId( const cmJsonNode_t* pairPtr );
  157. cmJsonNode_t* cmJsonPairValue( cmJsonNode_t* pairPtr );
  158. // Return values associated with the member values in the object
  159. // pointed to by object objectNodePtr.
  160. cmJsRC_t cmJsonUIntMember( const cmJsonNode_t* objectNodePtr, const char* label, unsigned* retPtr );
  161. cmJsRC_t cmJsonIntMember( const cmJsonNode_t* objectNodePtr, const char* label, int* retPtr );
  162. cmJsRC_t cmJsonRealMember( const cmJsonNode_t* objectNodePtr, const char* label, double* retPtr );
  163. cmJsRC_t cmJsonBoolMember( const cmJsonNode_t* objectNodePtr, const char* label, bool* retPtr );
  164. cmJsRC_t cmJsonStringMember( const cmJsonNode_t* objectNodePtr, const char* label, const char** retPtrPtr );
  165. // Returns array or object nodes.
  166. cmJsRC_t cmJsonNodeMember( const cmJsonNode_t* objectNodePtr, const char* label, cmJsonNode_t** nodePtrPtr );
  167. // Returns the value of the member pair named by 'label' or NULL if the
  168. // named pair does not exist.
  169. cmJsonNode_t* cmJsonNodeMemberValue( const cmJsonNode_t* np, const char* label );
  170. // Return values for specified pairs from an object node.
  171. //
  172. // The var args syntax is: <label>,<typeId>,<valuePtr>.
  173. // This functionis implemented in terms of cmJsonXXXMember().
  174. //
  175. // Add kOptArgJsFl to <typeId> if the member may not exist in
  176. // the object - otherwise the function will fail with a
  177. // kNodeNotFoundJsRC error and errLabelPtr will have the name of the missing pair.
  178. //
  179. // Terminate the var args list with NULL.
  180. //
  181. // Object,Array, and Pair members are returned as node pointers.
  182. //
  183. // Since kBoolTId does not exist use kTrueTId or kFalseTId to
  184. // return bool values.
  185. cmJsRC_t cmJsonVMemberValues(const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, va_list vl );
  186. cmJsRC_t cmJsonMemberValues( const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, ... );
  187. // If objectNodePtr is set to NULL then the tree root is used as the base for the search.
  188. // pathPrefix may be set to NULL.
  189. cmJsRC_t cmJsonPathToValueNode( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, const cmJsonNode_t** nodePtrPtr );
  190. cmJsRC_t cmJsonPathToBool( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, bool* retValPtr );
  191. cmJsRC_t cmJsonPathToInt( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, int* retValPtr );
  192. cmJsRC_t cmJsonPathToUInt( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, unsigned* retValPtr );
  193. cmJsRC_t cmJsonPathToReal( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, double* retValPtr );
  194. cmJsRC_t cmJsonPathToString( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, const char** retValPtr );
  195. cmJsRC_t cmJsonPathToPair( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, cmJsonNode_t** retValPtr );
  196. cmJsRC_t cmJsonPathToArray( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, cmJsonNode_t** retValPtr );
  197. cmJsRC_t cmJsonPathToObject( cmJsonH_t h, const cmJsonNode_t* objectNodePtr, const char* pathPrefix, const char* path, cmJsonNode_t** retValPtr );
  198. // Same as cmJsonMemberValues() except labels may be paths to a given variable.
  199. // These paths are equivalent to those used in cmJsonFindPathValue()
  200. // If objectNodePtr is NULL then the JSON tree root is used as the
  201. // base reference object.
  202. // If pathPrefix is non-NULL then it is appended to each of the
  203. // individual paths.
  204. cmJsRC_t cmJsonVPathValues(cmJsonH_t h, const char* pathPrefix, const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, va_list vl );
  205. cmJsRC_t cmJsonPathValues( cmJsonH_t h, const char* pathPrefix, const cmJsonNode_t* objectNodePtr, const char** errLabelPtrPtr, ... );
  206. // Set 'typeId' to the type of the new node.
  207. // Use 'intVal' for the value of int nodes.
  208. // Use 'realVal' for the value of real nodes.
  209. // Use 'stringVal' for the label of pairs and the value of string nodes.
  210. // 'retNodePtrPtr' is optional
  211. cmJsRC_t cmJsonCreate( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned typeId, const char* stringVal, int intVal, double realVal, cmJsonNode_t** newNodePtrPtr );
  212. // Insert new nodes in the tree. If the tree is empty then the first
  213. // inserted node will become the root (this must be an object or array node.).
  214. cmJsonNode_t* cmJsonCreateObject( cmJsonH_t h, cmJsonNode_t* parentPtr );
  215. cmJsonNode_t* cmJsonCreateArray( cmJsonH_t h, cmJsonNode_t* parentPtr );
  216. cmJsonNode_t* cmJsonCreatePair( cmJsonH_t h, cmJsonNode_t* parentPtr, const char* label );
  217. cmJsRC_t cmJsonCreateString( cmJsonH_t h, cmJsonNode_t* parentPtr, const char* stringValue );
  218. cmJsRC_t cmJsonCreateStringN(cmJsonH_t h, cmJsonNode_t* parentPtr, const char* stringValue, unsigned stringCharCnt );
  219. cmJsRC_t cmJsonCreateInt( cmJsonH_t h, cmJsonNode_t* parentPtr, int value );
  220. cmJsRC_t cmJsonCreateReal( cmJsonH_t h, cmJsonNode_t* parentPtr, double value );
  221. cmJsRC_t cmJsonCreateBool( cmJsonH_t h, cmJsonNode_t* parentPtr, bool value );
  222. cmJsRC_t cmJsonCreateNull( cmJsonH_t h, cmJsonNode_t* parentPtr );
  223. cmJsRC_t cmJsonCreateStringArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const char** values );
  224. cmJsRC_t cmJsonCreateIntArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const int* values );
  225. cmJsRC_t cmJsonCreateRealArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const double* values );
  226. cmJsRC_t cmJsonCreateBoolArray( cmJsonH_t h, cmJsonNode_t* parentPtr, unsigned n, const bool* values );
  227. //--------------------------------------------------------------------------------------------------------------
  228. //
  229. // Tree creation helper functiosn
  230. //
  231. cmJsRC_t cmJsonSetInt( cmJsonH_t h, cmJsonNode_t* np, int ival );
  232. cmJsRC_t cmJsonSetReal( cmJsonH_t h, cmJsonNode_t * np, double rval );
  233. cmJsRC_t cmJsonSetBool( cmJsonH_t h, cmJsonNode_t * np, bool bval );
  234. cmJsRC_t cmJsonSetString( cmJsonH_t h, cmJsonNode_t* np, const char* sval );
  235. // Insert a pair with a value indicated by 'typeId'.
  236. // 'stringVal','intVal' and 'realVal' are used as in cmJsonCreate().
  237. // Return a pointer to the new pair.
  238. cmJsonNode_t* cmJsonInsertPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned typeId, const char* stringVal, int intVal, double realVal );
  239. // Create a pair node and the associated label and value nodes and insert the pair in a parent object.
  240. // The object,array and pair creation functions return pointers to the pair value node.
  241. // These are helper functions that are implemented in terms of cmJsonCreateXXX() function.
  242. cmJsonNode_t* cmJsonInsertPairObject( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label );
  243. cmJsonNode_t* cmJsonInsertPairArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label );
  244. cmJsonNode_t* cmJsonInsertPairPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, const char* pairLabel );
  245. cmJsRC_t cmJsonInsertPairInt( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, int intVal );
  246. cmJsRC_t cmJsonInsertPairReal( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, double realVal );
  247. cmJsRC_t cmJsonInsertPairString( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, const char* string );
  248. cmJsRC_t cmJsonInsertPairStringN(cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, const char* string, unsigned stringCharCnt );
  249. cmJsRC_t cmJsonInsertPairBool( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, bool boolVal );
  250. cmJsRC_t cmJsonInsertPairNull( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label );
  251. cmJsRC_t cmJsonInsertPairIntArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const int* values );
  252. cmJsRC_t cmJsonInsertPairRealArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const double* values );
  253. cmJsRC_t cmJsonInsertPairStringArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const char** values );
  254. cmJsRC_t cmJsonInsertPairBoolArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const bool* values );
  255. // Returns pair pointer
  256. cmJsonNode_t* cmJsonInsertPairIntArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const int* values );
  257. cmJsonNode_t* cmJsonInsertPairRealArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const double* values );
  258. cmJsonNode_t* cmJsonInsertPairStringArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const char** values );
  259. cmJsonNode_t* cmJsonInsertPairBoolArray2( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned n, const bool* values );
  260. // Insert a pair (same as cmJsonInsertPair()) or if a pair
  261. // with a matching label/type already exists then replace the
  262. // existing value with a the new value.
  263. //
  264. // Set matchTypeMask with the type id's of all pair value types
  265. // which sould be considered a match. If matchTypeMask is set to
  266. // kInvalidTId then all value types will match.
  267. //
  268. // Return a pointer to the new or existing pair.
  269. //
  270. // When newTypeId == kObjectTId or kArrayTId then 'nv' may optionally be set to an object or array
  271. // to be set as the new value node for the selected pair. If 'nv' is NULL then an empty array or
  272. // object is created as the pair value node.
  273. //
  274. // When newTypeId == kPairTId then we are inserting/replacing a pair as the value of the selected pair.
  275. // In this case sv must be set to the new pair label. 'nv' may be optionally
  276. // set to a new pair value node. If 'nv' is NULL then the the new pair will have a value of type kNullTId
  277. 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 );
  278. // Returns pointer to object node.
  279. cmJsonNode_t* cmJsonInsertOrReplacePairObject( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newObjNodePtr );
  280. // Returns pointer to array node.
  281. cmJsonNode_t* cmJsonInsertOrReplacePairArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newArrayNodePtr );
  282. // Returns pointer to child pair node
  283. cmJsonNode_t* cmJsonInsertOrReplacePairPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* newPairLabel, cmJsonNode_t* newPairValNodePtr );
  284. cmJsRC_t cmJsonInsertOrReplacePairInt( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, int intVal );
  285. cmJsRC_t cmJsonInsertOrReplacePairReal( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, double realVal );
  286. cmJsRC_t cmJsonInsertOrReplacePairString( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* string );
  287. cmJsRC_t cmJsonInsertOrReplacePairBool( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, bool boolVal );
  288. cmJsRC_t cmJsonInsertOrReplacePairNull( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask );
  289. // Same as the above cmJsonInsertOrReplaceXXX() functions except
  290. // the function fails if a matching pair is not found.
  291. //
  292. // Replace a pair with the same name/type and return a pointer to the
  293. // effected pair. If a pair with the same name and type are not
  294. // found then no change is made and the function returns NULL.
  295. // For newTypeId=kObjectTId,kArrayTId,kPairTId the replaced pair node is blank,
  296. // in other words it will have no child nodes.
  297. 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 );
  298. // Returns pointer to object node.
  299. cmJsonNode_t* cmJsonReplacePairObject( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newObjNodePtr );
  300. // Return pointer to array node.
  301. cmJsonNode_t* cmJsonReplacePairArray( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, cmJsonNode_t* newArrayNodePtr );
  302. // Returns pointer to child pair node.
  303. cmJsonNode_t* cmJsonReplacePairPair( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* newPairLabel, cmJsonNode_t* newPairValueNodePtr );
  304. cmJsRC_t cmJsonReplacePairInt( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, int intVal );
  305. cmJsRC_t cmJsonReplacePairReal( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, double realVal );
  306. cmJsRC_t cmJsonReplacePairString( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, const char* string );
  307. cmJsRC_t cmJsonReplacePairBool( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask, bool boolVal );
  308. cmJsRC_t cmJsonReplacePairNull( cmJsonH_t h, cmJsonNode_t* objectNodePtr, const char* label, unsigned matchTypeMask );
  309. // Insert multiple pairs in a parent object. Terminate the pair sets with NULL.
  310. // Note that pair,int,real,bool, and string pairs are specified with 3 args: <label>,<typeId>,<value>
  311. // all others are specified with 2 args: <label>,<typeId>.
  312. // The last argument in this function must always be NULL.
  313. cmJsRC_t cmJsonVInsertPairs( cmJsonH_t h, cmJsonNode_t* objectNodePtr, va_list vl );
  314. cmJsRC_t cmJsonInsertPairs( cmJsonH_t h, cmJsonNode_t* objectNodePtr, ... );
  315. // Create an object node, fill it with the specified pairs, and return a pointer to
  316. // the new object node.
  317. // This function uses same var args syntax as cmJsonInsertPairs()
  318. cmJsonNode_t* cmJsonVCreateFilledObject( cmJsonH_t h, cmJsonNode_t* parentPtr, va_list vl );
  319. cmJsonNode_t* cmJsonCreateFilledObject( cmJsonH_t h, cmJsonNode_t* parentPtr, ... );
  320. //--------------------------------------------------------------------------------------------------------------
  321. // Remove a node from the tree by unlinking it from its
  322. // parent and siblings.
  323. // Set the freeFl to true if the node memory should also
  324. // be released.
  325. //
  326. // If 'freeFl' is false then np->ownerPtr and
  327. // np->siblingPtr remain valid when the function returns.
  328. // Even with the valid pointer however be careful
  329. // not to use the node in a way that it depends
  330. // on existing in the tree since the parent and
  331. // siblings will no longer know about it.
  332. //
  333. // If np is the root then the internal tree will be
  334. // cleared (i.e. cmJsonRoot(h) == NULL).
  335. //
  336. // This function will fail if 'np' points to the label value
  337. // of a pair node. Pair labels cannot be removed because this
  338. // would result in an invalid tree (all pairs must have two
  339. // child nodes where the first node is a string value). If 'np'
  340. // points to a pair value node then the value node is replaced
  341. // with a null node to maintain a valid pair structure.
  342. cmJsRC_t cmJsonRemoveNode( cmJsonH_t h, cmJsonNode_t* np, bool freeFl );
  343. //--------------------------------------------------------------------------------------------------------------
  344. // Duplicate the subtree pointed to by 'np' and attach it as a child
  345. // of the node pointed to by 'parentPtr'. This function performs a
  346. // deep copy of the subtree pointed to by np and returns the pointer
  347. // to the duplicated subtree.
  348. //
  349. // 'parentPtr' must be a legal parent for the sub-tree or NULL to not
  350. // attach the duplicate tree to any parent.
  351. //
  352. // The returned value is a pointer to the new subtree.
  353. //
  354. // If an error occurs the return value is NULL and cmJsonErrorCode()
  355. // can be used to obtain the code associated with the error.
  356. cmJsonNode_t* cmJsonDuplicateNode( cmJsonH_t h, const cmJsonNode_t* np, cmJsonNode_t* parentPtr );
  357. //--------------------------------------------------------------------------------------------------------------
  358. // Copy any pairs not found in the destintaion object from the
  359. // source object.
  360. // If an error occurs during merging the destination object is
  361. // returned unmodified. The most likely cause of an error is a
  362. // destination pair with the same name but different type
  363. // than a source pair.
  364. cmJsRC_t cmJsonMergeObjectNodes( cmJsonH_t h, cmJsonNode_t* destObjNodePtr, const cmJsonNode_t* srcObjNodePtr );
  365. //--------------------------------------------------------------------------------------------------------------
  366. // Validate the tree.
  367. cmJsRC_t cmJsonValidateTree( cmJsonH_t h );
  368. // Validate the tree beginning with np. Note that this function does
  369. // not print an error on failure but simply returns kValidateFailJsRC.
  370. cmJsRC_t cmJsonValidate( const cmJsonNode_t* np );
  371. // Get the count of bytes required to serialize the tree rooted at 'np'.
  372. unsigned cmJsonSerialByteCount( const cmJsonNode_t* np );
  373. // Serialize the tree rooted at 'np' into the buffer buf[bufByteCnt].
  374. cmJsRC_t cmJsonSerialize( const cmJsonNode_t* np, void* buf, unsigned bufByteCnt );
  375. // Serialize the subtree indicated by 'np' or the entire tree
  376. // if 'np' is NULL. The buffer created by this call will exist
  377. // for the life of 'h' or until the next call to cmJsonSerialize().
  378. // This function is implemented in terms of cmJsonSerialByteCount()
  379. // and cmJsonSerializeTree().
  380. cmJsRC_t cmJsonSerializeTree( cmJsonH_t h, const cmJsonNode_t* np, void** bufPtrPtr, unsigned* bufByteCntPtr);
  381. // Recreate the objects previously serialzed via cmJsonSerialize().
  382. // The tree held in the buffer will be reconstructed as a child of
  383. // altRootPtr (if it is non-NULL) or the internal root.
  384. // If altRootPtr is given then it must point to an array
  385. // or object node.
  386. cmJsRC_t cmJsonDeserialize( cmJsonH_t h, const void* bufPtr, cmJsonNode_t* altRootPtr );
  387. // Return a string/int/real/null/bool node as a string value.
  388. cmJsRC_t cmJsonLeafToString( const cmJsonNode_t* np, cmChar_t* buf, unsigned bufCharCnt );
  389. // Given a CSV file convert it to an array of JSON objects.
  390. // The first line of the CSV file must contain a comma seperated lists of types.
  391. // The type labels must be from the set: 'int','real','string','true','false'.
  392. // Note that either 'true' or 'false' can be use for boolean columns.
  393. // The seocnd line contains the field names as comma separated quoted strings.
  394. // For example "column1","column2","column3"
  395. // The data is presented as comma separated fields.
  396. // If parentNodePtr is NULL then the array will be created unattached to
  397. // the tree.
  398. // if arrayNodePtrPtr is non-NULL then the array node ptr will be returned.
  399. cmJsRC_t cmJsonFromCSV( cmJsonH_t h, const char* iFn, cmJsonNode_t* parentPtr, cmJsonNode_t** arrayNodePtrPtr );
  400. // Write a CSV file from an array of objects.
  401. // arrayNodePtr must point to an array of objects.
  402. cmJsRC_t cmJsonToCSV( cmJsonH_t h, const char* oFn, const cmJsonNode_t* arrayNodePtr );
  403. // Print the subtree using 'np as the root.
  404. void cmJsonPrintTree( const cmJsonNode_t* np, cmRpt_t* rpt );
  405. // Print the subtree using 'np' as the root to a file.
  406. // 'np' is optional and defaults to cmJsonRoot().
  407. cmJsRC_t cmJsonWrite( cmJsonH_t h, const cmJsonNode_t* np, const cmChar_t* fn );
  408. // Return the code of the last error generated. This is useful for the
  409. // the cmJsonCreateXXX() functions which do not return error codes but
  410. // may still fail.
  411. cmJsRC_t cmJsonErrorCode( cmJsonH_t h );
  412. void cmJsonClearErrorCode( cmJsonH_t h );
  413. // Validate the tree and print all the nodes.
  414. cmJsRC_t cmJsonReport( cmJsonH_t h );
  415. // Testing stub.
  416. cmJsRC_t cmJsonTest( const char* fn, cmCtx_t* ctx );
  417. //)
  418. //}
  419. #ifdef __cplusplus
  420. }
  421. #endif
  422. #endif