tests/standardjsonmessage.cc

   1 /**
   2  * Copyright (C) 2012  TOYOTA MOTOR CORPORATION.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  */
  19 #include <string.h>
  20
  21 #include <iostream>
  22
  23 #include <json-glib/json-glib.h>
  24
  25 #include "nullptr.h"
  26
  27 #include "standardjsonmessage.h"
  28
  29 JsonMessage::JsonMessage()
  30 {
  31 }
  32
  33 JsonMessage::~JsonMessage()
  34 {
  35     data.clear();
  36 }
  37
  38 char *
  39 JsonMessage::encode(std::string type_, std::string name_,
  40                     std::string transactionid_, std::vector<JsonData>& data_)
  41 {
  42     sstr.str("");
  43     sstr << "{\"type\":\"" << type_ << "\", \"name\":\"" << name_
  44          << "\", \"data\":[";
  45     for (auto itr = data_.begin(); itr != data_.end(); itr++) {
  46         if (itr != data_.begin()) {
  47             sstr << ",";
  48         }
  49         if (name_ != "set") {
  50             sstr << "\"" << (*itr).propertyName << "\"";
  51         }
  52         else {
  53             sstr << "{\"property\":\"" << (*itr).propertyName
  54                     << "\", \"value\":\"" << (*itr).value << "\"}";
  55         }
  56     }
  57     sstr << "],\"transactionid\":\"" << transactionid_ << "\"}";
  58     memset(encodebuf, 0, sizeof(encodebuf));
  59     memcpy(encodebuf, const_cast<char*>(sstr.str().c_str()), sizeof(encodebuf));
  60     return &encodebuf[0];
  61 }
  62
  63 void
  64 JsonMessage::decode(std::string msg, size_t len)
  65 {
  66     data.clear();
  67
  68     JsonParser* parser = json_parser_new();
  69     GError* error = nullptr;
  70     if (!json_parser_load_from_data(parser, msg.c_str(), len, &error)) {
  71         std::cerr << "Failed to load config: " << error->message << '\n';
  72         return;
  73     }
  74
  75     JsonNode* node = json_parser_get_root(parser);
  76
  77     if (node == nullptr) {
  78         std::cerr << "Unable to get JSON root object\n";
  79         return;
  80     }
  81
  82     JsonReader* reader = json_reader_new(node);
  83
  84     if (reader == nullptr) {
  85         std::cerr << "Unable to create JSON reader\n";
  86         return;
  87     }
  88
  89     if (json_reader_read_member(reader, "type")) {
  90         type = std::string(json_reader_get_string_value(reader));
  91         json_reader_end_member(reader);
  92     }
  93     else {
  94         std::cerr << "Error Get type\n";
  95         return;
  96     }
  97
  98     if (json_reader_read_member(reader, "name")) {
  99         name = std::string(json_reader_get_string_value(reader));
 100         json_reader_end_member(reader);
 101     }
 102     else {
 103         std::cerr << "Error Get name\n";
 104         return;
 105     }
 106
 107     if (json_reader_read_member(reader, "transactionid")) {
 108         transactionid = std::string(json_reader_get_string_value(reader));
 109         json_reader_end_member(reader);
 110     }
 111     else {
 112         std::cerr << "Error Get transactionid\n";
 113         return;
 114     }
 115
 116     if (json_reader_read_member(reader, "data")) {
 117         if (json_reader_is_array(reader)) {
 118             JsonData jdata;
 119             for (int i = 0; i < json_reader_count_elements(reader); i++) {
 120                 json_reader_read_element(reader, i);
 121                 if (json_reader_is_object(reader)) {
 122                     if (json_reader_read_member(reader, "property")) {
 123                         jdata.propertyName = std::string(
 124                                 json_reader_get_string_value(reader));
 125                         json_reader_end_member(reader);
 126                     }
 127                     if (json_reader_read_member(reader, "value")) {
 128                         jdata.value = std::string(
 129                                 json_reader_get_string_value(reader));
 130                         json_reader_end_member(reader);
 131                     }
 132                     if (json_reader_read_member(reader, "timestamp")) {
 133                         jdata.timestamp = json_reader_get_double_value(reader);
 134                         json_reader_end_member(reader);
 135                     }
 136                     if (json_reader_read_member(reader, "sequence")) {
 137                         jdata.sequence = json_reader_get_int_value(reader);
 138                         json_reader_end_member(reader);
 139                     }
 140                     data.push_back(jdata);
 141                 }
 142                 else if (json_reader_is_value(reader)) {
 143                     jdata.propertyName = std::string(
 144                             json_reader_get_string_value(reader));
 145                     data.push_back(jdata);
 146                 }
 147                 json_reader_end_element(reader);
 148             }
 149         }
 150         else {
 151             JsonData jdata;
 152             if (json_reader_is_object(reader)) {
 153                 if (type == "valuechanged") {
 154                     jdata.propertyName = name;
 155                 }
 156                 else {
 157                     if (json_reader_read_member(reader, "property")) {
 158                         jdata.propertyName = std::string(
 159                                 json_reader_get_string_value(reader));
 160                         json_reader_end_member(reader);
 161                     }
 162                 }
 163                 if (json_reader_read_member(reader, "value")) {
 164                     jdata.value = std::string(
 165                             json_reader_get_string_value(reader));
 166                     json_reader_end_member(reader);
 167                 }
 168                 else {
 169                     std::cerr << "Error Get value\n";
 170                     return;
 171                 }
 172                 if (json_reader_read_member(reader, "timestamp")) {
 173                     jdata.timestamp = json_reader_get_double_value(reader);
 174                     json_reader_end_member(reader);
 175                 }
 176                 else {
 177                     std::cerr << "Error Get timestamp\n";
 178                     return;
 179                 }
 180                 if (json_reader_read_member(reader, "sequence")) {
 181                     jdata.sequence = json_reader_get_int_value(reader);
 182                     json_reader_end_member(reader);
 183                 }
 184                 else {
 185                     std::cerr << "Error Get sequence\n";
 186                     return;
 187                 }
 188             }
 189             else if (json_reader_is_value(reader)) {
 190                 jdata.propertyName = std::string(
 191                         json_reader_get_string_value(reader));
 192             }
 193             data.push_back(jdata);
 194         }
 195     }
 196     else {
 197         std::cerr << "Error Get data\n";
 198         return;
 199     }
 200     json_reader_end_member(reader);
 201
 202     if (error)
 203         g_error_free(error);
 204
 205     g_object_unref(reader);
 206     g_object_unref(parser);
 207 }
 208
 209 std::string
 210 JsonMessage::getType()
 211 {
 212     return type;
 213 }
 214
 215 std::string
 216 JsonMessage::getName()
 217 {
 218     return name;
 219 }
 220
 221 std::string
 222 JsonMessage::getTransactionid()
 223 {
 224     return transactionid;
 225 }
 226
 227 std::vector<JsonData>
 228 JsonMessage::getData()
 229 {
 230     return data;
 231 }