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 << "]." << endl;
  81         return ret;
  82     }
  83
  84     JsonNode *node = json_parser_get_root(parser);
  85     if (node == nullptr) {
  86         cerr << "Unable to get JSON root object." << endl;
  87         DebugOut() << "Unable to get JSON root object." << endl;
  88         return ret;
  89     }
  90
  91     JsonReader *reader = json_reader_new(node);
  92     if (reader == nullptr) {
  93         cerr << "Unable to create JSON reader." << endl;
  94         DebugOut() << "Unable to create JSON reader." << endl;
  95         return ret;
  96     }
  97
  98     json_reader_read_member(reader, "Config");
  99     const GError *configReadError = json_reader_get_error(reader);
 100     if (configReadError != nullptr) {
 101         cerr << "Error getting sources member["
 102              << configReadError->message << "]." << endl;
 103         DebugOut() << "Error getting sources member["
 104                    << configReadError->message << "]." << endl;
 105         return ret;
 106     }
 107     g_assert(json_reader_is_array(reader));
 108
 109     int sectionNum = json_reader_count_elements(reader);
 110     string section = "";
 111     for (int i = 0; i < sectionNum; i++) {
 112         json_reader_read_element(reader, i);
 113         json_reader_read_member(reader, "Section");
 114         section = std::string(json_reader_get_string_value(reader));
 115         json_reader_end_member(reader);
 116
 117         if (section == "Common") {
 118             json_reader_read_member(reader, "VehicleInfoDefine");
 119             int elementNum = json_reader_count_elements(reader);
 120
 121             bool fcontinue = true;
 122             int statusNum = 0;
 123             for (int i = 0; i < elementNum; i++) {
 124                 fcontinue = true;
 125                 VehicleInfoDefine vid;
 126                 json_reader_read_element(reader, i);
 127                 json_reader_read_member(reader, "KeyEventType");
 128                 strcpy(vid.KeyEventType, json_reader_get_string_value(reader));
 129                 json_reader_end_member(reader);
 130
 131                 for (auto itr = vehicleinfoList.begin();
 132                         itr != vehicleinfoList.end(); itr++) {
 133                     if (strcmp(vid.KeyEventType, (*itr).KeyEventType) == 0) {
 134                         json_reader_end_element(reader);
 135                         fcontinue = false;
 136                         break;
 137                     }
 138                 }
 139                 if (!fcontinue) {
 140                     continue;
 141                 }
 142
 143                 json_reader_read_member(reader, "Priority");
 144                 vid.priority = json_reader_get_int_value(reader);
 145                 json_reader_end_member(reader);
 146
 147                 json_reader_read_member(reader, "DBusInterface");
 148                 vid.dbusInterface = json_reader_get_string_value(reader);
 149                 json_reader_end_member(reader);
 150
 151                 json_reader_read_member(reader, "DBusObject");
 152                 vid.dbusObject = json_reader_get_string_value(reader);
 153                 json_reader_end_member(reader);
 154
 155                 json_reader_read_member(reader, "Status");
 156                 statusNum = json_reader_count_elements(reader);
 157
 158                 for (int j = 0; j < statusNum; j++) {
 159                     VehicleInfoDefine::Status status;
 160                     json_reader_read_element(reader, j);
 161                     json_reader_read_member(reader, "AMBPropertyName");
 162                     status.ambPropertyName = json_reader_get_string_value(
 163                             reader);
 164                     json_reader_end_member(reader);
 165
 166                     json_reader_read_member(reader, "Type");
 167                     status.type = getType(
 168                             const_cast<char*>(json_reader_get_string_value(
 169                                     reader)),
 170                             &status.typesize);
 171                     json_reader_end_member(reader);
 172
 173                     json_reader_read_member(reader, "Default");
 174                     status.defaultvalue = std::string(
 175                             json_reader_get_string_value(reader));
 176                     json_reader_end_member(reader);
 177
 178                     json_reader_read_member(reader, "AccessControl");
 179                     status.accessControl = std::string(
 180                             json_reader_get_string_value(reader));
 181                     json_reader_end_member(reader);
 182
 183                     json_reader_read_member(reader, "DBusProperty");
 184                     status.dbusPropertyName = std::string(
 185                             json_reader_get_string_value(reader));
 186                     json_reader_end_member(reader);
 187
 188                     json_reader_end_member(reader);
 189                     json_reader_end_element(reader);
 190
 191                     json_reader_read_member(reader, "Status");
 192                     vid.status.push_back(status);
 193                 }
 194                 vehicleinfoList.push_back(vid);
 195
 196                 json_reader_end_member(reader);
 197                 json_reader_end_element(reader);
 198
 199             }
 200             json_reader_end_member(reader);
 201             ret = true;
 202             json_reader_read_member(reader, "DefaultInfoPort");
 203             json_reader_read_member(reader, "DataPort");
 204             portinfo.standard.dataPort = json_reader_get_int_value(reader);
 205             json_reader_end_member(reader);
 206             json_reader_read_member(reader, "CtrlPort");
 207             portinfo.standard.controlPort = json_reader_get_int_value(reader);
 208             json_reader_end_member(reader);
 209             json_reader_end_member(reader);
 210             json_reader_read_member(reader, "CustomizeInfoPort");
 211             json_reader_read_member(reader, "DataPort");
 212             portinfo.custom.dataPort = json_reader_get_int_value(reader);
 213             json_reader_end_member(reader);
 214             json_reader_read_member(reader, "CtrlPort");
 215             portinfo.custom.controlPort = json_reader_get_int_value(reader);
 216             json_reader_end_member(reader);
 217             json_reader_end_member(reader);
 218         }
 219
 220         json_reader_end_element(reader);
 221     }
 222
 223     json_reader_end_member(reader);
 224     g_object_unref(reader);
 225     g_object_unref(parser);
 226     return ret;
 227 }
 228
 229 VehicleInfoDefine::Status::DataType
 230 Config::getType(char *type, int *size)
 231 {
 232     if (strcmp(type, "int") == 0) {
 233         *size = sizeof(int);
 234         return VehicleInfoDefine::Status::INT;
 235     }
 236     else if (strcmp(type, "double") == 0) {
 237         *size = sizeof(double);
 238         return VehicleInfoDefine::Status::DOUBLE;
 239     }
 240     else if (strcmp(type, "char") == 0) {
 241         *size = sizeof(char);
 242         return VehicleInfoDefine::Status::CHAR;
 243     }
 244     else if (strcmp(type, "int16_t") == 0 || strcmp(type, "int16") == 0) {
 245         *size = sizeof(int16_t);
 246         return VehicleInfoDefine::Status::INT16;
 247     }
 248     else if (strcmp(type, "uint16_t") == 0 || strcmp(type, "uint16") == 0) {
 249         *size = sizeof(uint16_t);
 250         return VehicleInfoDefine::Status::UINT16;
 251     }
 252     else if (strcmp(type, "uint32_t") == 0 || strcmp(type, "uint32") == 0) {
 253         *size = sizeof(uint32_t);
 254         return VehicleInfoDefine::Status::UINT32;
 255     }
 256     else if (strcmp(type, "int64_t") == 0 || strcmp(type, "int64") == 0) {
 257         *size = sizeof(int64_t);
 258         return VehicleInfoDefine::Status::INT64;
 259     }
 260     else if (strcmp(type, "uint64_t") == 0 || strcmp(type, "uint64") == 0) {
 261         *size = sizeof(uint64_t);
 262         return VehicleInfoDefine::Status::UINT64;
 263     }
 264     else if (strcmp(type, "bool") == 0 || strcmp(type, "boolean") == 0) {
 265         *size = sizeof(bool);
 266         return VehicleInfoDefine::Status::BOOL;
 267     }
 268     return VehicleInfoDefine::Status::NONE;
 269 }