libcm is a C development framework with an emphasis on audio signal processing applications.
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。

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