Line data    Source code

       1             : 
       2             : /* Copyright (c) 2016, Human Brain Project
       3             :  *                     Stefan.Eilemann@epfl.ch
       4             :  */
       5             : 
       6             : #include "json.h"
       7             : #include "Zerobuf.h"
       8             : #include "detail/base64.h"
       9             : #include "jsoncpp/json/json.h"
      10             : 
      11             : namespace zerobuf
      12             : {
      13             : template <>
      14           6 : ZEROBUF_INL bool fromJSON(const Json::Value& json)
      15             : {
      16           6 :     return json.asBool();
      17             : }
      18             : template <>
      19          14 : ZEROBUF_INL int8_t fromJSON(const Json::Value& json)
      20             : {
      21          14 :     return json.asInt();
      22             : }
      23             : template <>
      24          18 : ZEROBUF_INL uint8_t fromJSON(const Json::Value& json)
      25             : {
      26          18 :     return json.asUInt();
      27             : }
      28             : template <>
      29          28 : ZEROBUF_INL int16_t fromJSON(const Json::Value& json)
      30             : {
      31          28 :     return json.asInt();
      32             : }
      33             : template <>
      34          31 : ZEROBUF_INL uint16_t fromJSON(const Json::Value& json)
      35             : {
      36          31 :     return json.asUInt();
      37             : }
      38             : template <>
      39          59 : ZEROBUF_INL int32_t fromJSON(const Json::Value& json)
      40             : {
      41          59 :     return json.asInt();
      42             : }
      43             : template <>
      44          54 : ZEROBUF_INL uint32_t fromJSON(const Json::Value& json)
      45             : {
      46          54 :     return json.asUInt();
      47             : }
      48             : template <>
      49          14 : ZEROBUF_INL int64_t fromJSON(const Json::Value& json)
      50             : {
      51          14 :     return json.asInt64();
      52             : }
      53             : template <>
      54          28 : ZEROBUF_INL uint64_t fromJSON(const Json::Value& json)
      55             : {
      56          28 :     return json.asUInt64();
      57             : }
      58             : template <>
      59          14 : ZEROBUF_INL float fromJSON(const Json::Value& json)
      60             : {
      61          14 :     return json.asFloat();
      62             : }
      63             : template <>
      64          14 : ZEROBUF_INL double fromJSON(const Json::Value& json)
      65             : {
      66          14 :     return json.asDouble();
      67             : }
      68             : template <>
      69          16 : ZEROBUF_INL std::string fromJSON(const Json::Value& json)
      70             : {
      71          16 :     return json.asString();
      72             : }
      73             : template <>
      74          14 : ZEROBUF_INL uint128_t fromJSON(const Json::Value& json)
      75             : {
      76          14 :     return {json["high"].asUInt64(), json["low"].asUInt64()};
      77             : }
      78             : 
      79             : template <class T>
      80         456 : void toJSON(const T& value, Json::Value& json)
      81             : {
      82         456 :     json = Json::Value(value);
      83         456 : }
      84             : template ZEROBUF_INL void toJSON(const bool&, Json::Value&);
      85             : template ZEROBUF_INL void toJSON(const int8_t&, Json::Value&);
      86             : template ZEROBUF_INL void toJSON(const int16_t&, Json::Value&);
      87             : template ZEROBUF_INL void toJSON(const int32_t&, Json::Value&);
      88             : template ZEROBUF_INL void toJSON(const uint32_t&, Json::Value&);
      89             : template ZEROBUF_INL void toJSON(const float&, Json::Value&);
      90             : template ZEROBUF_INL void toJSON(const double&, Json::Value&);
      91             : template ZEROBUF_INL void toJSON(const std::string&, Json::Value&);
      92             : template <>
      93          32 : ZEROBUF_INL void toJSON(const uint8_t& value, Json::Value& json)
      94             : {
      95          32 :     json = Json::UInt(value);
      96          32 : }
      97             : template <>
      98          48 : ZEROBUF_INL void toJSON(const uint16_t& value, Json::Value& json)
      99             : {
     100          48 :     json = Json::UInt(value);
     101          48 : }
     102             : template <>
     103          24 : ZEROBUF_INL void toJSON(const int64_t& value, Json::Value& json)
     104             : {
     105          24 :     json = Json::Int64(value);
     106          24 : }
     107             : template <>
     108          48 : ZEROBUF_INL void toJSON(const uint64_t& value, Json::Value& json)
     109             : {
     110          48 :     json = Json::UInt64(value);
     111          48 : }
     112             : template <>
     113          24 : ZEROBUF_INL void toJSON(const uint128_t& value, Json::Value& json)
     114             : {
     115          24 :     json["high"] = Json::UInt64(value.high());
     116          24 :     json["low"] = Json::UInt64(value.low());
     117          24 : }
     118             : 
     119          84 : void emptyJSONArray(Json::Value& value)
     120             : {
     121          84 :     value = Json::Value(Json::arrayValue);
     122          84 : }
     123             : 
     124          29 : void fromJSON(const Json::Value& json, Zerobuf& zerobuf)
     125             : {
     126          29 :     zerobuf._parseJSON(json);
     127          29 : }
     128             : 
     129          70 : void toJSON(const Zerobuf& zerobuf, Json::Value& json)
     130             : {
     131          70 :     zerobuf._createJSON(json);
     132          70 : }
     133             : 
     134           8 : std::string fromJSONBinary(const Json::Value& json)
     135             : {
     136           8 :     return base64_decode(json.asString());
     137             : }
     138             : 
     139          16 : void toJSONBinary(const uint8_t* data, const size_t size, Json::Value& json)
     140             : {
     141          16 :     json = Json::Value(base64_encode(data, uint32_t(size)));
     142          16 : }
     143             : 
     144         326 : bool hasJSONField(const Json::Value& json, const std::string& field)
     145             : {
     146         326 :     return json.isMember(field);
     147             : }
     148             : 
     149         198 : const Json::Value& getJSONField(const Json::Value& json,
     150             :                                 const std::string& field)
     151             : {
     152         198 :     return json[field];
     153             : }
     154             : 
     155         504 : Json::Value& getJSONField(Json::Value& json, const std::string& field)
     156             : {
     157         504 :     return json[field];
     158             : }
     159             : 
     160         224 : const Json::Value& getJSONField(const Json::Value& json, const size_t index)
     161             : {
     162         224 :     return json[unsigned(index)];
     163             : }
     164             : 
     165         370 : Json::Value& getJSONField(Json::Value& json, const size_t index)
     166             : {
     167         370 :     return json[unsigned(index)];
     168             : }
     169             : 
     170          39 : size_t getJSONSize(const Json::Value& json)
     171             : {
     172          39 :     return json.size();
     173             : }
     174             : }