直播技术>> Untyped-cpp>> 返回
项目作者： peychart

项目描述 ：
A Javascript style object in C++ and serialization
高级语言： C++
项目地址: git://github.com/peychart/Untyped-cpp.git
创建时间： 2020-06-21T00:56:24Z
项目社区：https://github.com/peychart/Untyped-cpp
开源协议：
下载


Javascript data in c++

Software:

C++ source.

  • Object that manages the standard types of c ++ in the std::vector and std::map structures.

Examples of use: serialization, json objects management, backup of memory contexts, configuration files management, etc … or, MQTT communications, with a small memory footprint.

Here is a code that I wrote a few years ago, just for fun (and to learn c++) of an untyped object, standard C++ data container, now modified to handle serialization in format Json in my iot projects - this to replace the old libraries by manual reservation of memory spaces … ;-)

Allows:

  • use data similar to Javascript variables,
  • binary (de)serialization in/from files, streams or strings,
  • json (de)serialization in/from files, streams or strings,
  • and, of course, a self-managed memory space (nothing more than a c++ flavor).

Here, an intuitive example of HTML communication in an iot project : https://github.com/peychart/WiFiPowerStrip/blob/master/C%2B%2Bsource/webPage.cpp

Below, more examples of use:

  1. # define out /*
  2. g++ -std=c++0x -rdynamic -Wall -s -O2 -o test $0 untyped.cpp; exit $?
  3. # define out */
  4. # undef out
  6. #include "untyped.h"
  7. #include <fstream>
  9. int main() {            // ****** Intuitive syntax ******
  11. untyped    myJson('j');
  12. myJson.json();    // <-- set the JSON format management in (de)serialization methods.
  14. std::cout << myJson                    << std::endl;
  15. //-> 'j'        // <-- type char
  17. std::cout << ( myJson + 'A' - 'a' )            << std::endl;
  18. //-> 'J'
  20. myJson = "aaaJaaa";
  21. std::cout << ( myJson + 's' + "on" - "aaa" - "aaa" )    << std::endl;
  22. //-> "Json"        // <-- type string
  24. myJson.binary();    // <-- BINARY format management
  25. std::cout << ( myJson + 's' + "on" - "aaa" - "aaa" )    << std::endl;
  26. //-> Json        // <-- std::string
  28. myJson.json();          // <-- Json format
  29. myJson("                                \
  30. {                                    \
  31.     \"name\":        \"Armstrong\",                    \
  32.     \"firstname\":   \"Neil\",                        \
  33.     \"birthday\":  { \"year\" : 1930, \"month\" : 8, \"day\": 5 },    \
  34.     \"profession\":[ \"pilot\", \"engineer\", \"astronaut\" ],        \
  35.     \"born in\":     \"Wapakoneta - Ohio\",                \
  36.     \"hobbies\": [                            \
  37.         \"astronomy\",                            \
  38.         \"X-15\",                            \
  39.         \"First Man to Walk on the Moon\"                \
  40.     ]                                    \
  41. }                                    \
  42. ");
  43. std::cout << myJson["birthday"]["year"] + 39 << std::endl;
  44. //-> 1969
  47.             // ****** Implicit or explicit cast ******
  49. myJson = 31.4159e-1;        // <-- implicite double
  50. auto myDouble = myJson;
  51. std::cout << "myDouble   = " << myDouble        << std::endl;
  52. //-> myDouble   = 3.14159    // <-- implicite double
  54. std::cout << "cast<float>= " << myDouble.value<float>()<< std::endl;
  55. //-> cast<float>= 3.14159    // <-- explicite float
  57. std::cout << "cast<int>  = " << myDouble.value<int>()    << std::endl;
  58. //-> cast<int>  = 3        // <-- explicite int
  60. std::cout << "cast<bool> = " << myDouble.value<bool>()    << std::endl;
  61. //-> cast<bool> = 1        // <-- explicite bool
  65.         // ****** Automatic memory allocation, as close as needed ******
  66. myJson.clear();
  67. myJson[0]=10;
  68. myJson[1]=11;
  69. myJson[myJson.vector().size()]=12;
  70. myJson[myJson.vector().size()]=13;
  72. myJson.json();
  73. std::cout << myJson << std::endl;
  74. //-> [10,11,12,13]
  76. untyped tmp;
  77. tmp["array1"] = myJson;
  78. tmp["array2"] = myJson; tmp["array2"][3]=23;
  79. tmp["array3"] = myJson; tmp["array3"][2]=32;
  80. tmp["array4"] = myJson; tmp["array4"][1]=41;
  81. myJson = tmp; tmp.clear();
  82. std::cout << myJson << std::endl;
  83. //-> {"array1":[10,11,12,13],"array2":[10,11,12,23],"array3":[10,11,32,13],"array4":[10,41,12,13]}
  87.                 // ****** Serialization ******
  88. myJson.clear().json();
  89. myJson["string"] = "abcdef";
  90. myJson["char"] = 'a';
  91. myJson["bool"] = true;
  92. myJson["int"] = 15;
  93. myJson["double"] = -3.14159;
  94. myJson["array"][3] = -13;
  95. myJson["array"][2] = -12;
  96. myJson["array"][1] = -11;
  97. myJson["array"][0] = -10;
  98. myJson["empty"] = untyped();
  99. std::cout << myJson << std::endl;
  100. //-> {"array":[-10,-11,-12,-13],"bool":true,"char":'a',"double":-3.14159,"empty":null,"int":15,"string":"abcdef"}
  102.                         // From a std::pair
  103. std::cout << untyped(std::pair<std::string,double>{"pi", 3.14159}).serializeJson() << std::endl;
  104. //-> {"pi":3.14159}
  108.                 // Deserialize from a std::stream:
  110. std::stringstream       myStream( std::stringstream::in | std::stringstream::out );
  112. myStream  << "{\"array\":[-10,-11,-12,-13], \"objectArray\" : [{\"o1\":false},{\"o2\":true} , {\"o3\":false}],\"bool\":true,\"char\":'a',\"double\":-3.14159,\"empty\":\"\",\"void\":null,\"int\":15,\"string\":\"abcdef\"}";
  114. std::cout << myJson.deserializeJson( myStream )  << std::endl;
  115. //-> {"array":[-10,-11,-12,-13],"bool":true,"char":'a',"double":-3.14159,"empty":"","int":15,"objectArray":[{"o1":false,"o2":true},{"o1":true,"o2":true},{"o1":true,"o2":false}],"string":"abcdef","void":null}
  117. std::cout << myJson["objectArray"][1]["o2"] << std::endl;
  118. //-> true
  120. std::cout << myJson["objectArray"][2]["o3"] << std::endl;
  121. //-> false
  122. //...
  124. myStream  << "{\"array\":[-10,-11,-12,-13], \"objectArray\" : [{\"o1\":false},{\"o2\":true} , {\"o3\":false}],\"bool\":true,\"char\":'a',\"double\":-3.14159,\"empty\":\"\",\"void\":null,\"int\":15,\"string\":\"abcdef\"}";
  126. std::cout << untyped().json()( myStream )["objectArray"] << std::endl;
  127. //-> [{"o1":false},{"o2":true},{"o3":false}]
  130.                 // From a C string (or std::string)
  131. std::cout << myJson.deserializeJson("[0,1,2,3]") << std::endl;
  132. //-> [0,1,2,3]
  134.                 // <-- the same thing, with a short syntax...
  135. std::cout << myJson("[0,-1,-2,-4+1]")              << std::endl;
  136. //-> [0,-1,-2,-3]
  138. // *** WARNING *** --> Different from: untyped myJson("[0,-1,-2,-3]"), a simple initialisation from a C string ; so:
  139. {    untyped tmp( "[0,-1,-2,-3]" );            // <-- init with a C string
  140.     tmp.json();
  141.     std::cout << tmp << std::endl;            // <-- std::string
  142.     //-> "[0,-1,-2,-3]"
  143.     std::cout << tmp.string().at(2) << std::endl;    // <-- check
  144.     //-> ,
  145.     std::cout << "c_str()=" << tmp.c_str() << std::endl;
  146.     //-> c_str()=[0,-1,-2,-3]
  147.     std::cout << tmp.vector().size() << std::endl;    // <-- check
  148.     //-> 0
  150.     tmp( tmp.c_str() );                // <-- deserialisation from a string...
  152.     std::cout << tmp << std::endl;            // <-- std::vector
  153.     //-> [0,-1,-2,-3]
  154.     std::cout << tmp.vector().at(2) << std::endl;    // <-- check
  155.     //-> -2
  156.     std::cout << "Here: c_str()=" << tmp.c_str() << std::endl;
  157.     //-> Here: c_str()=
  158.     std::cout << "but: serializeJson().c_str()=" << tmp.serializeJson().c_str() is a string...<< std::endl;
  159.     //-> but: serializeJson().c_str()=[0,-1,-2,-3] is a string...
  160. }
  163.                 // From std::string to std::stream
  164. myStream=std::stringstream();
  165. untyped().deserializeJson("[ 4 ,-5,   2 ]").serializeJson( myStream );
  166. std::cout << myStream.str() << std::endl;
  167. //-> [4,-5,2]
  169.                 // From std::string to std::string:
  170. std::cout << untyped().deserializeJson("[ 'a' ,'b',   'c' ]")[2].serializeJson() << std::endl;
  171. //-> 'c'
  175.                 // ****** Indented output ******
  176. myStream=std::stringstream();
  177. myJson.prettyJson(2); // <-- default tab size is 1 when no arg...
  179. myStream  << "{\"array\":[-10,-11,-12,-13], \"objectArray\" : [{\"o1\":false},{\"o2\":true} , {\"o3\":false
  180. std::cout << myJson(myStream) << std::endl;
  181. //or, directly: std::cout << myJson.prettyJson(2)(myStream) << std::endl;
  182. //-> {
  183. //->   "array": [
  184. //->     -10,
  185. //->     -11,
  186. //->     -12,
  187. //->     -13
  188. //->   ],
  189. //->   "bool": true,
  190. //->   "char": 'a',
  191. //->   "double": -3.14159,
  192. //->   "empty": "",
  193. //->   "int": 15,
  194. //->   "objectArray": [
  195. //->     {
  196. //->       "o1": false
  197. //->     },
  198. //->     {
  199. //->       "o2": true
  200. //->     },
  201. //->     {
  202. //->       "o3": false
  203. //->     }
  204. //->   ],
  205. //->   "string": "abcdef",
  206. //->   "void": null
  207. //-> }
  209.                                 // in/from FILE:
  210. std::ofstream    outBinFile("/tmp/serialize.bin", std::ifstream::trunc|std::ifstream::binary);
  211. std::ifstream    inBinFile ("/tmp/serialize.bin", std::ofstream::binary);
  213. std::ofstream    outTxtFile("/tmp/serialize.json", std::ifstream::trunc);
  214. std::ifstream    inTxtFile ("/tmp/serialize.json", std::ofstream::in);
  216. myJson.binary();
  217. myJson.serialize( outBinFile );
  218. myJson.serializeJson( outTxtFile );
  219. outBinFile.flush(); outTxtFile.flush();
  221. std::cout << untyped()( inBinFile )["string"] << std::endl;
  222. //-> abcdef                    // <-- Only what is needed...
  224. std::cout << inBinFile.tellg() << " octets deserialized from file." << std::endl;
  225. //-> 305 octets deserialized from file.
  227. std::cout << untyped().json()( inTxtFile )["double"] << std::endl << std::endl;
  228. //-> -3.14159                // <-- Extract only what is necessary...
  230. std::cout << inTxtFile.tellg() << " octets deserialized from file." << std::endl << std::endl;
  231. //-> 172 octets deserialized from file.
  233.                 // ****** Comments ******
  234. myStream=std::stringstream();
  235. myStream << "{/* This is a comment */ \"name\":\"Beno\u00EEt\"  /* This is an other comment */  }";
  236. std::cout << untyped().json()( myStream ) << std::endl << std::endl;
  237. //-> {"name":"Benoît"}
  239. return(0);
  240. }