src/config.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 <fstream>
  22 #include <iostream>
  23 #include <stdexcept>
  24
  25 #include <json-glib/json-glib.h>
  26
  27 #include "debugout.h"
  28 #include "nullptr.h"
  29
  30 #include "config.h"
  31
  32 using std::string;
  33 using std::vector;
  34
  35 Config::Config()
  36 {
  37 }
  38
  39 Config::~Config()
  40 {
  41     vehicleinfoList.clear();
  42 }
  43
  44 bool
  45 Config::readConfig(std::string confpath)
  46 {
  47     std::ifstream in(confpath, std::ios::in);
  48     std::string output;
  49     std::string line;
  50     while (in.good()) {
  51         getline(in, line);
  52         output.append(line);
  53     }
  54     return parseJson(output);
  55 }
  56
  57 vector<VehicleInfoDefine>
  58 Config::getVehicleInfoConfig()
  59 {
  60     return vehicleinfoList;
  61 }
  62
  63 PortInfo
  64 Config::getPort()
  65 {
  66     return portinfo;
  67 }
  68
  69 bool
  70 Config::parseJson(string config)
  71 {
  72     /* ToDo */
  73     /* json_reader_read_member's error check. */
  74     bool ret = false;
  75     JsonParser *parser = json_parser_new();
  76     GError *error = nullptr;
  77     if (!json_parser_load_from_data(parser, config.c_str(), config.length(),
  78                                     &error)) {
  79         cerr << "Failed to load config[" << error->message << "]." << endl;
  80         DebugOut() << "Failed to load config[" << error->message << "]."
  81                 << endl;
  82         return ret;
  83     }
  84
  85     JsonNode *node = json_parser_get_root(parser);
  86     if (node == nullptr) {
  87         cerr << "Unable to get JSON root object." << endl;
  88         DebugOut() << "Unable to get JSON root object." << endl;
  89         return ret;
  90     }
  91
  92     JsonReader *reader = json_reader_new(node);
  93     if (reader == nullptr) {
  94         cerr << "Unable to create JSON reader." << endl;
  95         DebugOut() << "Unable to create JSON reader." << endl;
  96         return ret;
  97     }
  98
  99     json_reader_read_member(reader, "Config");
 100     const GError *configReadError = json_reader_get_error(reader);
 101     if (configReadError != nullptr) {
 102         cerr << "Error getting sources member[" << configReadError->message
 103                 << "]." << endl;
 104         DebugOut() << "Error getting sources member["
 105                 << configReadError->message << "]." << endl;
 106         return ret;
 107     }
 108     g_assert(json_reader_is_array(reader));
 109
 110     int sectionNum = json_reader_count_elements(reader);
 111     string section = "";
 112     for (int i = 0; i < sectionNum; i++) {
 113         json_reader_read_element(reader, i);
 114         json_reader_read_member(reader, "Section");
 115         section = std::string(json_reader_get_string_value(reader));
 116         json_reader_end_member(reader);
 117
 118         if (section == "Common") {
 119             json_reader_read_member(reader, "VehicleInfoDefine");
 120             int elementNum = json_reader_count_elements(reader);
 121
 122             bool fcontinue = true;
 123             int statusNum = 0;
 124             for (int i = 0; i < elementNum; i++) {
 125                 fcontinue = true;
 126                 VehicleInfoDefine vid;
 127                 json_reader_read_element(reader, i);
 128                 json_reader_read_member(reader, "KeyEventType");
 129                 strcpy(vid.KeyEventType, json_reader_get_string_value(reader));
 130                 json_reader_end_member(reader);
 131
 132                 for (auto itr = vehicleinfoList.begin();
 133                         itr != vehicleinfoList.end(); itr++) {
 134                     if (strcmp(vid.KeyEventType, (*itr).KeyEventType) == 0) {
 135                         json_reader_end_element(reader);
 136                         fcontinue = false;
 137                         break;
 138                     }
 139                 }
 140                 if (!fcontinue) {
 141                     continue;
 142                 }
 143
 144                 json_reader_read_member(reader, "Priority");
 145                 vid.priority = json_reader_get_int_value(reader);
 146                 json_reader_end_member(reader);
 147
 148                 json_reader_read_member(reader, "DBusInterface");
 149                 vid.dbusInterface = json_reader_get_string_value(reader);
 150                 json_reader_end_member(reader);
 151
 152                 json_reader_read_member(reader, "DBusObject");
 153                 vid.dbusObject = json_reader_get_string_value(reader);
 154                 json_reader_end_member(reader);
 155
 156                 json_reader_read_member(reader, "Status");
 157                 statusNum = json_reader_count_elements(reader);
 158
 159                 for (int j = 0; j < statusNum; j++) {
 160                     VehicleInfoDefine::Status status;
 161                     json_reader_read_element(reader, j);
 162                     json_reader_read_member(reader, "AMBPropertyName");
 163                     status.ambPropertyName = json_reader_get_string_value(
 164                             reader);
 165                     json_reader_end_member(reader);
 166
 167                     json_reader_read_member(reader, "Type");
 168                     status.type = getType(
 169                             const_cast<char*>(json_reader_get_string_value(
 170                                     reader)),
 171                             &status.typesize);
 172                     json_reader_end_member(reader);
 173
 174                     json_reader_read_member(reader, "Default");
 175                     status.defaultvalue = std::string(
 176                             json_reader_get_string_value(reader));
 177                     json_reader_end_member(reader);
 178
 179                     json_reader_read_member(reader, "AccessControl");
 180                     status.accessControl = std::string(
 181                             json_reader_get_string_value(reader));
 182                     json_reader_end_member(reader);
 183
 184                     json_reader_read_member(reader, "DBusProperty");
 185                     status.dbusPropertyName = std::string(
 186                             json_reader_get_string_value(reader));
 187                     json_reader_end_member(reader);
 188
 189                     json_reader_end_member(reader);
 190                     json_reader_end_element(reader);
 191
 192                     json_reader_read_member(reader, "Status");
 193                     vid.status.push_back(status);
 194                 }
 195                 vehicleinfoList.push_back(vid);
 196
 197                 json_reader_end_member(reader);
 198                 json_reader_end_element(reader);
 199
 200             }
 201             json_reader_end_member(reader);
 202             ret = true;
 203             json_reader_read_member(reader, "DefaultInfoPort");
 204             json_reader_read_member(reader, "DataPort");
 205             portinfo.standard.dataPort = json_reader_get_int_value(reader);
 206             json_reader_end_member(reader);
 207             json_reader_read_member(reader, "CtrlPort");
 208             portinfo.standard.controlPort = json_reader_get_int_value(reader);
 209             json_reader_end_member(reader);
 210             json_reader_end_member(reader);
 211             json_reader_read_member(reader, "CustomizeInfoPort");
 212             json_reader_read_member(reader, "DataPort");
 213             portinfo.custom.dataPort = json_reader_get_int_value(reader);
 214             json_reader_end_member(reader);
 215             json_reader_read_member(reader, "CtrlPort");
 216             portinfo.custom.controlPort = json_reader_get_int_value(reader);
 217             json_reader_end_member(reader);
 218             json_reader_end_member(reader);
 219         }
 220
 221         json_reader_end_element(reader);
 222     }
 223
 224     json_reader_end_member(reader);
 225     g_object_unref(reader);
 226     g_object_unref(parser);
 227     return ret;
 228 }
 229
 230 VehicleInfoDefine::Status::DataType
 231 Config::getType(char *type, int *size)
 232 {
 233     if (strcmp(type, "int") == 0) {
 234         *size = sizeof(int);
 235         return VehicleInfoDefine::Status::INT;
 236     }
 237     else if (strcmp(type, "double") == 0) {
 238         *size = sizeof(double);
 239         return VehicleInfoDefine::Status::DOUBLE;
 240     }
 241     else if (strcmp(type, "char") == 0) {
 242         *size = sizeof(char);
 243         return VehicleInfoDefine::Status::CHAR;
 244     }
 245     else if (strcmp(type, "int16_t") == 0 || strcmp(type, "int16") == 0) {
 246         *size = sizeof(int16_t);
 247         return VehicleInfoDefine::Status::INT16;
 248     }
 249     else if (strcmp(type, "uint16_t") == 0 || strcmp(type, "uint16") == 0) {
 250         *size = sizeof(uint16_t);
 251         return VehicleInfoDefine::Status::UINT16;
 252     }
 253     else if (strcmp(type, "uint32_t") == 0 || strcmp(type, "uint32") == 0) {
 254         *size = sizeof(uint32_t);
 255         return VehicleInfoDefine::Status::UINT32;
 256     }
 257     else if (strcmp(type, "int64_t") == 0 || strcmp(type, "int64") == 0) {
 258         *size = sizeof(int64_t);
 259         return VehicleInfoDefine::Status::INT64;
 260     }
 261     else if (strcmp(type, "uint64_t") == 0 || strcmp(type, "uint64") == 0) {
 262         *size = sizeof(uint64_t);
 263         return VehicleInfoDefine::Status::UINT64;
 264     }
 265     else if (strcmp(type, "bool") == 0 || strcmp(type, "boolean") == 0) {
 266         *size = sizeof(bool);
 267         return VehicleInfoDefine::Status::BOOL;
 268     }
 269     return VehicleInfoDefine::Status::NONE;
 270 }