service/simulator/ramlparser/raml/jsonSchemaParser/JsonSchema.cpp

   1 /******************************************************************\r
   2  *\r
   3  * Copyright 2015 Samsung Electronics All Rights Reserved.\r
   4  *\r
   5  *\r
   6  *\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  *\r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  *\r
  19  ******************************************************************/\r
  20 \r
  21 /**\r
  22  * @file   JsonSchema.cpp\r
  23  *\r
  24  * @brief   This file reads data from Json Schema.\r
  25  */\r
  26 \r
  27 #include "JsonSchema.h"\r
  28 #include <iostream>\r
  29 namespace RAML\r
  30 {\r
  31 \r
  32     void JsonSchema::readJson()\r
  33     {\r
  34         if (! m_cjson)\r
  35             return;\r
  36 \r
  37         cJSON *jsonId = cJSON_GetObjectItem(m_cjson, "id");\r
  38         if (jsonId)\r
  39         {\r
  40             m_id = jsonId->valuestring;\r
  41         }\r
  42         cJSON *jsonSchema = cJSON_GetObjectItem(m_cjson, "$schema");\r
  43         if (jsonSchema)\r
  44         {\r
  45             m_schema = jsonSchema->valuestring;\r
  46         }\r
  47         cJSON *jsonTitle = cJSON_GetObjectItem(m_cjson, "title");\r
  48         if (jsonTitle)\r
  49         {\r
  50             m_title = jsonTitle->valuestring;\r
  51         }\r
  52         cJSON *jsonType = cJSON_GetObjectItem(m_cjson, "type");\r
  53         if (jsonType)\r
  54         {\r
  55             m_type = jsonType->valuestring;\r
  56         }\r
  57         cJSON *jsonDescription = cJSON_GetObjectItem(m_cjson, "description");\r
  58         if (jsonDescription)\r
  59         {\r
  60             m_description = jsonDescription->valuestring;\r
  61         }\r
  62         cJSON *jsonDefinitions = cJSON_GetObjectItem(m_cjson, "definitions");\r
  63         if (jsonDefinitions)\r
  64         {\r
  65             cJSON *childDefinitions = jsonDefinitions->child;\r
  66             while (childDefinitions)\r
  67             {\r
  68                 std::string defName = childDefinitions->string;\r
  69                 addDefinition(defName, readDef(childDefinitions, defName));\r
  70                 childDefinitions = childDefinitions->next;\r
  71             }\r
  72         }\r
  73         cJSON *jsonProperties = cJSON_GetObjectItem(m_cjson, "properties");\r
  74         if (jsonProperties)\r
  75         {\r
  76             cJSON *childProperties = jsonProperties->child;\r
  77             while (childProperties)\r
  78             {\r
  79                 std::string attName = childProperties->string;\r
  80                 addProperty(attName, readProp(childProperties, attName));\r
  81                 childProperties = childProperties->next;\r
  82             }\r
  83         }\r
  84         if (m_type == "array")\r
  85         {\r
  86             PropertiesPtr property = std::make_shared<Properties>("array");\r
  87             readArray(m_cjson, property);\r
  88             addProperty("array" , property);\r
  89         }\r
  90 \r
  91         cJSON *jsonAdditionalProperties = cJSON_GetObjectItem(m_cjson, "additionalProperties");\r
  92         if (jsonAdditionalProperties)\r
  93             m_additionalProperties = (jsonAdditionalProperties->type == cJSON_True);\r
  94         else\r
  95             m_additionalProperties = true;\r
  96 \r
  97         cJSON *jsonReference = cJSON_GetObjectItem(m_cjson, "$ref");\r
  98         if (jsonReference)\r
  99         {\r
 100             JsonParameters param;\r
 101             readJsonRef(jsonReference, param);\r
 102 \r
 103             for (auto it : param.getProperties())\r
 104             {\r
 105                 addProperty(it.first, it.second);\r
 106             }\r
 107             for ( auto it : param.getRequired())\r
 108             {\r
 109                 setRequiredValue(it);\r
 110             }\r
 111             if (m_type.empty())\r
 112                 m_type = param.getType();\r
 113         }\r
 114         cJSON *jsonAllOf = cJSON_GetObjectItem(m_cjson, "allOf");\r
 115         if (jsonAllOf)\r
 116         {\r
 117             JsonParameters param;\r
 118 \r
 119             readAllOf(jsonAllOf, param);\r
 120 \r
 121             for (auto it : param.getProperties())\r
 122             {\r
 123                 addProperty(it.first, it.second);\r
 124             }\r
 125             for ( auto it : param.getRequired())\r
 126             {\r
 127                 setRequiredValue(it);\r
 128             }\r
 129             if (m_type.empty())\r
 130                 m_type = param.getType();\r
 131         }\r
 132         cJSON *jsonRequiredValues = cJSON_GetObjectItem(m_cjson, "required");\r
 133         if (jsonRequiredValues)\r
 134         {\r
 135             int size = cJSON_GetArraySize(jsonRequiredValues);\r
 136             int index = 0;\r
 137             do\r
 138             {\r
 139                 setRequiredValue(cJSON_GetArrayItem(jsonRequiredValues, index)->valuestring);\r
 140             }\r
 141             while ( ++index < size);\r
 142         }\r
 143     }\r
 144 \r
 145     DefinitionsPtr JsonSchema::readDef(cJSON *childDefinitions, const std::string &defName)\r
 146     {\r
 147         DefinitionsPtr definition = std::make_shared<Definitions>(defName);\r
 148 \r
 149         cJSON *defType = cJSON_GetObjectItem(childDefinitions, "type");\r
 150         if (defType)\r
 151         {\r
 152             std::string type = defType->valuestring;\r
 153             definition->setType(type);\r
 154             if (type == "array")\r
 155             {\r
 156                 PropertiesPtr property = std::make_shared<Properties>("array");\r
 157                 readArray(childDefinitions, property);\r
 158                 definition->addProperty("array" , property);\r
 159             }\r
 160         }\r
 161         cJSON *defProperties = cJSON_GetObjectItem(childDefinitions, "properties");\r
 162         if (defProperties)\r
 163         {\r
 164             cJSON *childProperties = defProperties->child;\r
 165             while (childProperties)\r
 166             {\r
 167                 std::string attName = childProperties->string;\r
 168                 definition->addProperty(attName, readProp(childProperties, attName));\r
 169                 childProperties = childProperties->next;\r
 170             }\r
 171         }\r
 172         cJSON *defRequiredValues = cJSON_GetObjectItem(childDefinitions, "required");\r
 173         if (defRequiredValues)\r
 174         {\r
 175             int size = cJSON_GetArraySize(defRequiredValues);\r
 176             int index = 0;\r
 177             do\r
 178             {\r
 179                 definition->setRequiredValue(cJSON_GetArrayItem(defRequiredValues, index)->valuestring);\r
 180             }\r
 181             while ( ++index < size);\r
 182         }\r
 183         cJSON *defReference = cJSON_GetObjectItem(childDefinitions, "$ref");\r
 184         if (defReference)\r
 185         {\r
 186             JsonParameters param;\r
 187             readJsonRef(defReference, param);\r
 188 \r
 189             for (auto it : param.getProperties())\r
 190             {\r
 191                 definition->addProperty(it.first, it.second);\r
 192             }\r
 193             for ( auto it : param.getRequired())\r
 194             {\r
 195                 definition->setRequiredValue(it);\r
 196             }\r
 197             if (definition->getType().empty())\r
 198                 definition->setType(param.getType());\r
 199         }\r
 200         cJSON *defAllOf = cJSON_GetObjectItem(childDefinitions, "allOf");\r
 201         if (defAllOf)\r
 202         {\r
 203             JsonParameters param;\r
 204             readAllOf(defAllOf, param);\r
 205 \r
 206             for (auto it : param.getProperties())\r
 207             {\r
 208                 definition->addProperty(it.first, it.second);\r
 209             }\r
 210             for ( auto it : param.getRequired())\r
 211             {\r
 212                 definition->setRequiredValue(it);\r
 213             }\r
 214             if (definition->getType().empty())\r
 215                 definition->setType(param.getType());\r
 216         }\r
 217         return definition;\r
 218     }\r
 219 \r
 220     PropertiesPtr JsonSchema::readProp(cJSON *childProperties, const std::string &attName )\r
 221     {\r
 222         PropertiesPtr property = std::make_shared<Properties>(attName);\r
 223 \r
 224         cJSON *propertyDescription = cJSON_GetObjectItem(childProperties, "description");\r
 225         if (propertyDescription)\r
 226         {\r
 227             property->setDescription(propertyDescription->valuestring);\r
 228         }\r
 229         cJSON *propertyType = cJSON_GetObjectItem(childProperties, "type");\r
 230         std::string attType;\r
 231         if (propertyType)\r
 232         {\r
 233             if (propertyType->type == cJSON_String)\r
 234             {\r
 235                 attType = propertyType->valuestring;\r
 236             }\r
 237             else if (propertyType->type == cJSON_Array)\r
 238             {\r
 239                 attType = cJSON_GetArrayItem(propertyType, 0)->valuestring;\r
 240             }\r
 241         }\r
 242         if (!(attType == "array") && !(attType == "object"))\r
 243         {\r
 244             cJSON *defaultValue = cJSON_GetObjectItem(childProperties, "default");\r
 245             if (defaultValue)\r
 246             {\r
 247                 readDefaultValue(defaultValue, property, attType);\r
 248             }\r
 249         }\r
 250         readValues(childProperties, property, attType);\r
 251         cJSON *allowedvalues = cJSON_GetObjectItem(childProperties, "enum");\r
 252         if (allowedvalues)\r
 253         {\r
 254             readAllowedValues(allowedvalues, property, attType);\r
 255         }\r
 256         property->setTypeString(attType);\r
 257         return property;\r
 258     }\r
 259 \r
 260     void JsonSchema::readDefaultValue(cJSON *defaultValue,  PropertiesPtr &property,\r
 261                                       const std::string &attType)\r
 262     {\r
 263         if (defaultValue->type == cJSON_String)\r
 264         {\r
 265             property->setValue((std::string)defaultValue->valuestring);\r
 266         }\r
 267         else if (defaultValue->type == cJSON_Number)\r
 268         {\r
 269             if (attType == "number")\r
 270                 property->setValue((double)defaultValue->valuedouble);\r
 271             else\r
 272                 property->setValue((int)defaultValue->valueint );\r
 273         }\r
 274         else if (defaultValue->type == cJSON_True)\r
 275         {\r
 276             property->setValue((bool)true);\r
 277         }\r
 278         else if (defaultValue->type == cJSON_False)\r
 279         {\r
 280             property->setValue((bool)false);\r
 281         }\r
 282     }\r
 283 \r
 284     void JsonSchema::readAllowedValues(cJSON *allowedvalues,  PropertiesPtr &property,\r
 285                                        std::string &attType)\r
 286     {\r
 287         if ((cJSON_GetArrayItem(allowedvalues, 0)->type) == cJSON_String)\r
 288         {\r
 289             int size = cJSON_GetArraySize(allowedvalues);\r
 290             int idx = 0;\r
 291             std::vector<std::string> allwdValues;\r
 292             do\r
 293             {\r
 294                 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valuestring);\r
 295             }\r
 296             while ( ++idx < size);\r
 297             property->setValueProperty(std::make_shared<ValueProperty>(allwdValues));\r
 298             if (attType.empty())\r
 299                 attType = "string";\r
 300         }\r
 301         else if ((cJSON_GetArrayItem(allowedvalues, 0)->type) == cJSON_Number)\r
 302         {\r
 303             int size = cJSON_GetArraySize(allowedvalues);\r
 304             int idx = 0;\r
 305             if (attType == "number")\r
 306             {\r
 307                 std::vector<double> allwdValues;\r
 308                 do\r
 309                 {\r
 310                     allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valuedouble);\r
 311                 }\r
 312                 while ( ++idx < size);\r
 313                 property->setValueProperty(std::make_shared<ValueProperty>(allwdValues));\r
 314             }\r
 315             else\r
 316             {\r
 317                 std::vector<int> allwdValues;\r
 318                 do\r
 319                 {\r
 320                     allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valueint);\r
 321                 }\r
 322                 while ( ++idx < size);\r
 323                 property->setValueProperty(std::make_shared<ValueProperty>(allwdValues));\r
 324                 if (attType.empty())\r
 325                     attType = "integer";\r
 326             }\r
 327         }\r
 328         else if (((cJSON_GetArrayItem(allowedvalues, 0)->type) == cJSON_True)\r
 329                  || ((cJSON_GetArrayItem(allowedvalues, 0)->type) == cJSON_False))\r
 330         {\r
 331             int size = cJSON_GetArraySize(allowedvalues);\r
 332             int idx = 0;\r
 333             std::vector<bool> allwdValues;\r
 334             do\r
 335             {\r
 336                 if (cJSON_GetArrayItem(allowedvalues, idx)->type != cJSON_False)\r
 337                     allwdValues.push_back(true);\r
 338                 else\r
 339                     allwdValues.push_back(false);\r
 340             }\r
 341             while ( ++idx < size);\r
 342             property->setValueProperty(std::make_shared<ValueProperty>(allwdValues));\r
 343             if (attType.empty())\r
 344                 attType = "boolean";\r
 345         }\r
 346     }\r
 347 \r
 348     void JsonSchema::readValues(cJSON *childProperties,  PropertiesPtr &property ,\r
 349                                 const std::string &attType)\r
 350     {\r
 351         if (attType == "string")\r
 352         {\r
 353             readString(childProperties, property);\r
 354         }\r
 355         else if (attType == "integer")\r
 356         {\r
 357             readInteger(childProperties, property);\r
 358         }\r
 359         else if (attType == "number")\r
 360         {\r
 361             readDouble(childProperties, property);\r
 362         }\r
 363         else if (attType == "array")\r
 364         {\r
 365             readArray(childProperties, property);\r
 366         }\r
 367         else if (attType == "object")\r
 368         {\r
 369             readObject(childProperties, property);\r
 370         }\r
 371     }\r
 372 \r
 373     void JsonSchema::readString(cJSON *childProperties, PropertiesPtr &property)\r
 374     {\r
 375         cJSON *stringMax = cJSON_GetObjectItem(childProperties, "maxLength");\r
 376         int min = INT_MIN, max = INT_MAX;\r
 377         if (stringMax)\r
 378         {\r
 379             cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");\r
 380             if (exclusiveMax)\r
 381             {\r
 382                 if (exclusiveMax->type == cJSON_True)\r
 383                     max = --(stringMax->valueint);\r
 384                 else\r
 385                     max = stringMax->valueint;\r
 386             }\r
 387             else\r
 388                 max = stringMax->valueint;\r
 389         }\r
 390         cJSON *stringMin = cJSON_GetObjectItem(childProperties, "minLength");\r
 391         if (stringMin)\r
 392         {\r
 393             cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");\r
 394             if (exclusiveMin)\r
 395             {\r
 396                 if (exclusiveMin->type == cJSON_True)\r
 397                     min = ++(stringMin->valueint);\r
 398                 else\r
 399                     min = stringMin->valueint;\r
 400             }\r
 401             else\r
 402                 min = stringMin->valueint;\r
 403         }\r
 404         if (min != INT_MIN || max != INT_MAX)\r
 405             property->setValueProperty(std::make_shared<ValueProperty>(min, max, 0));\r
 406 \r
 407         cJSON *stringFormat = cJSON_GetObjectItem(childProperties, "format");\r
 408         if (stringFormat)\r
 409         {\r
 410             property->setValueProperty(std::make_shared<ValueProperty>\r
 411                                        (ValueProperty::Type::FORMAT, (stringFormat->valuestring)));\r
 412         }\r
 413 \r
 414         cJSON *stringPattern = cJSON_GetObjectItem(childProperties, "pattern");\r
 415         if (stringPattern)\r
 416         {\r
 417             property->setValueProperty(std::make_shared<ValueProperty>\r
 418                                        (ValueProperty::Type::PATTERN, (stringPattern->valuestring)));\r
 419         }\r
 420     }\r
 421 \r
 422     void JsonSchema::readInteger(cJSON *childProperties,  PropertiesPtr &property)\r
 423     {\r
 424         cJSON *Max = cJSON_GetObjectItem(childProperties, "maximum");\r
 425         int min = INT_MIN, max = INT_MAX, multipleOf = INT_MAX;\r
 426         if (Max)\r
 427         {\r
 428             cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");\r
 429             if (exclusiveMax)\r
 430             {\r
 431                 if (exclusiveMax->type == cJSON_True)\r
 432                     max = --(Max->valueint);\r
 433                 else\r
 434                     max = Max->valueint;\r
 435             }\r
 436             else\r
 437                 max = Max->valueint;\r
 438         }\r
 439         cJSON *Min = cJSON_GetObjectItem(childProperties, "minimum");\r
 440         if (Min)\r
 441         {\r
 442             cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");\r
 443             if (exclusiveMin)\r
 444             {\r
 445                 if (exclusiveMin->type == cJSON_True)\r
 446                     min = ++(Min->valueint);\r
 447                 else\r
 448                     min = Min->valueint;\r
 449             }\r
 450             else\r
 451                 min = Min->valueint;\r
 452         }\r
 453         cJSON *MultipleOff = cJSON_GetObjectItem(childProperties, "multipleOf");\r
 454         if (MultipleOff)\r
 455         {\r
 456             multipleOf = MultipleOff->valueint;\r
 457         }\r
 458         if (min != INT_MIN || max != INT_MAX)\r
 459             property->setValueProperty(std::make_shared<ValueProperty>(min, max, multipleOf));\r
 460 \r
 461     }\r
 462 \r
 463     void JsonSchema::readDouble(cJSON *childProperties,  PropertiesPtr &property)\r
 464     {\r
 465         cJSON *Max = cJSON_GetObjectItem(childProperties, "maximum");\r
 466         double min = INT_MIN, max = INT_MAX;\r
 467         int multipleOf = INT_MAX;\r
 468         if (Max)\r
 469         {\r
 470             cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");\r
 471             if (exclusiveMax)\r
 472             {\r
 473                 if (exclusiveMax->type == cJSON_True)\r
 474                     max = --(Max->valuedouble);\r
 475                 else\r
 476                     max = Max->valuedouble;\r
 477             }\r
 478             else\r
 479                 max = Max->valuedouble;\r
 480         }\r
 481         cJSON *Min = cJSON_GetObjectItem(childProperties, "minimum");\r
 482         if (Min)\r
 483         {\r
 484             cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");\r
 485             if (exclusiveMin)\r
 486             {\r
 487                 if (exclusiveMin->type == cJSON_True)\r
 488                     min = ++(Min->valuedouble);\r
 489                 else\r
 490                     min = Min->valuedouble;\r
 491             }\r
 492             else\r
 493                 min = Min->valuedouble;\r
 494         }\r
 495 \r
 496         cJSON *MultipleOff = cJSON_GetObjectItem(childProperties, "multipleOf");\r
 497         if (MultipleOff)\r
 498         {\r
 499             multipleOf = MultipleOff->valueint;\r
 500         }\r
 501         if (min != INT_MIN || max != INT_MAX)\r
 502             property->setValueProperty(std::make_shared<ValueProperty>(min, max, multipleOf));\r
 503 \r
 504     }\r
 505 \r
 506     void JsonSchema::readArray(cJSON *childProperties,  PropertiesPtr &property)\r
 507     {\r
 508         cJSON *itemValues = cJSON_GetObjectItem(childProperties, "items");\r
 509         if (itemValues)\r
 510         {\r
 511             if (itemValues->type == cJSON_Array)\r
 512             {\r
 513                 //int item_size = cJSON_GetArraySize(itemValues);\r
 514                 int item_index = 0;\r
 515                 //do\r
 516                 //{\r
 517                 cJSON *item = cJSON_GetArrayItem(itemValues, item_index);\r
 518                 readItems(item, property);\r
 519                 //break;\r
 520                 //}\r
 521                 //while ( ++item_index < item_size);\r
 522             }\r
 523             else\r
 524             {\r
 525                 readItems(itemValues, property);\r
 526             }\r
 527         }\r
 528         cJSON *itemsMax = cJSON_GetObjectItem(childProperties, "maxItems");\r
 529         int min = INT_MIN, max = INT_MAX;\r
 530         bool unique = false, addItems = false;\r
 531         if (itemsMax)\r
 532         {\r
 533             cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");\r
 534             if (exclusiveMax)\r
 535             {\r
 536                 if (exclusiveMax->type == cJSON_True)\r
 537                     max = --(itemsMax->valueint);\r
 538                 else\r
 539                     max = itemsMax->valueint;\r
 540             }\r
 541             else\r
 542                 max = itemsMax->valueint;\r
 543         }\r
 544         cJSON *itemsMin = cJSON_GetObjectItem(childProperties, "minItems");\r
 545         if (itemsMin)\r
 546         {\r
 547             cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");\r
 548             if (exclusiveMin)\r
 549             {\r
 550                 if (exclusiveMin->type == cJSON_True)\r
 551                     min = ++(itemsMin->valueint);\r
 552                 else\r
 553                     min = itemsMin->valueint;\r
 554             }\r
 555             else\r
 556                 min = itemsMin->valueint;\r
 557         }\r
 558         cJSON *uniqueItems = cJSON_GetObjectItem(childProperties, "uniqueItems");\r
 559         if (uniqueItems)\r
 560         {\r
 561             unique = (uniqueItems->type == cJSON_True);\r
 562         }\r
 563         cJSON *additionalItems = cJSON_GetObjectItem(childProperties, "additionalItems");\r
 564         if (additionalItems)\r
 565         {\r
 566             addItems = (additionalItems->type == cJSON_True);\r
 567         }\r
 568         property->setValueProperty(std::make_shared<ValueProperty>\r
 569                                    (ValueProperty::Type::ARRAY, min, max, unique, addItems));\r
 570     }\r
 571 \r
 572     void JsonSchema::readItems(cJSON *item, PropertiesPtr &property)\r
 573     {\r
 574         std::string type;\r
 575         JsonParameters param;\r
 576         cJSON *itemType = cJSON_GetObjectItem(item, "type");\r
 577         if (itemType)\r
 578         {\r
 579             type = itemType->valuestring;\r
 580         }\r
 581 \r
 582         cJSON *itemAllOf = cJSON_GetObjectItem(item, "allOf");\r
 583         if (itemAllOf)\r
 584         {\r
 585             readAllOf(itemAllOf , param);\r
 586         }\r
 587         else\r
 588         {\r
 589             cJSON *itemOneOf = cJSON_GetObjectItem(item, "oneOf");\r
 590             if (itemOneOf)\r
 591             {\r
 592                 readAllOf(itemOneOf , param);\r
 593             }\r
 594         }\r
 595 \r
 596         cJSON *itemReference = cJSON_GetObjectItem(item, "$ref");\r
 597         if (itemReference)\r
 598         {\r
 599             readJsonRef(itemReference , param);\r
 600         }\r
 601 \r
 602         if (type == "object")\r
 603         {\r
 604             cJSON *itemProperties = cJSON_GetObjectItem(item, "properties");\r
 605             if (itemProperties)\r
 606             {\r
 607                 cJSON *childProperties = itemProperties->child;\r
 608                 std::vector<Properties> propertyVector;\r
 609                 while (childProperties)\r
 610                 {\r
 611                     std::string attName = childProperties->string;\r
 612                     PropertiesPtr prop = std::make_shared<Properties>(attName);\r
 613                     readProp(childProperties, attName);\r
 614                     propertyVector.push_back(*prop);\r
 615                     childProperties = childProperties->next;\r
 616                 }\r
 617                 property->setValue(propertyVector);\r
 618             }\r
 619 \r
 620             cJSON *itemRequiredValues = cJSON_GetObjectItem(item, "required");\r
 621             if (itemRequiredValues)\r
 622             {\r
 623                 int size = cJSON_GetArraySize(itemRequiredValues);\r
 624                 int index = 0;\r
 625                 do\r
 626                 {\r
 627                     property->setRequiredValue(cJSON_GetArrayItem(itemRequiredValues, index)->valuestring);\r
 628                 }\r
 629                 while ( ++index < size);\r
 630             }\r
 631         }\r
 632 \r
 633         else if (param.getType() == "object")\r
 634         {\r
 635             std::vector<Properties> propertyVector;\r
 636             for (auto prop : param.getProperties())\r
 637             {\r
 638                 propertyVector.push_back(*(prop.second));\r
 639             }\r
 640             property->setValue(propertyVector);\r
 641 \r
 642             for (auto req : param.getRequired())\r
 643             {\r
 644                 property->setRequiredValue(req);\r
 645             }\r
 646         }\r
 647         else\r
 648         {\r
 649             PropertiesPtr prop = std::make_shared<Properties>("property");\r
 650 \r
 651             cJSON *defaultValue = cJSON_GetObjectItem(item, "default");\r
 652             if (defaultValue)\r
 653             {\r
 654                 readDefaultValue(defaultValue, prop, type);\r
 655             }\r
 656             cJSON *allowedvalues = cJSON_GetObjectItem(item, "enum");\r
 657             if (allowedvalues)\r
 658             {\r
 659                 readAllowedValues(allowedvalues, prop, type);\r
 660             }\r
 661             readValues(item, prop, type);\r
 662             prop->setTypeString(type);\r
 663             property->setValue(*prop);\r
 664         }\r
 665     }\r
 666 \r
 667     void JsonSchema::readObject(cJSON *childProperties,  PropertiesPtr &property)\r
 668     {\r
 669         property->setTypeString("object");\r
 670 \r
 671         cJSON *subProperties = cJSON_GetObjectItem(childProperties, "properties");\r
 672         cJSON *itemRequiredValues = cJSON_GetObjectItem(childProperties, "required");\r
 673         if (subProperties)\r
 674         {\r
 675             cJSON *childProperties = subProperties->child;\r
 676             std::vector<Properties> propertyVector;\r
 677             while (childProperties)\r
 678             {\r
 679                 std::string attName = childProperties->string;\r
 680                 PropertiesPtr prop = std::make_shared<Properties>(attName);\r
 681                 readProp(childProperties, attName);\r
 682                 propertyVector.push_back(*prop);\r
 683                 childProperties = childProperties->next;\r
 684             }\r
 685             property->setValue(propertyVector);\r
 686             if (itemRequiredValues)\r
 687             {\r
 688                 int size = cJSON_GetArraySize(itemRequiredValues);\r
 689                 int index = 0;\r
 690                 do\r
 691                 {\r
 692                     property->setRequiredValue(cJSON_GetArrayItem(itemRequiredValues, index)->valuestring);\r
 693                 }\r
 694                 while ( ++index < size);\r
 695             }\r
 696         }\r
 697         else\r
 698         {\r
 699             JsonParameters param;\r
 700 \r
 701             cJSON *itemAllOf = cJSON_GetObjectItem(childProperties, "allOf");\r
 702             if (itemAllOf)\r
 703             {\r
 704                 readAllOf(itemAllOf , param);\r
 705             }\r
 706             cJSON *itemReference = cJSON_GetObjectItem(childProperties, "$ref");\r
 707             if (itemReference)\r
 708             {\r
 709                 readJsonRef(itemReference , param);\r
 710             }\r
 711 \r
 712             if (param.getType() == "object")\r
 713             {\r
 714                 std::vector<Properties> propertyVector;\r
 715                 for (auto prop : param.getProperties())\r
 716                 {\r
 717                     propertyVector.push_back(*(prop.second));\r
 718                 }\r
 719                 property->setValue(propertyVector);\r
 720 \r
 721                 for (auto req : param.getRequired())\r
 722                 {\r
 723                     property->setRequiredValue(req);\r
 724                 }\r
 725             }\r
 726         }\r
 727     }\r
 728 \r
 729     void JsonSchema::readFile(std::string &fileName ,  JsonParameters &param)\r
 730     {\r
 731         std::string name = fileName;\r
 732         std::transform(name.begin(), name.end(), name.begin(), ::tolower);\r
 733         if (name.compare("oic.baseresource.json") == 0)\r
 734             return;\r
 735 \r
 736         cJSON *json = m_includeResolver->readToJson(fileName);\r
 737         JsonSchemaPtr Refparser = std::make_shared<JsonSchema>(json, m_includeResolver);\r
 738 \r
 739         param.addProperties(Refparser->getProperties());\r
 740         param.addRequired(Refparser->getRequiredValues());\r
 741         param.setType(Refparser->getType());\r
 742     }\r
 743 \r
 744     void JsonSchema::readFile(std::string &fileName , std::string &defName ,  JsonParameters &param)\r
 745     {\r
 746         std::string name = fileName;\r
 747         std::transform(name.begin(), name.end(), name.begin(), ::tolower);\r
 748         if (name.compare("oic.baseresource.json") == 0)\r
 749             return;\r
 750 \r
 751         cJSON *json = m_includeResolver->readToJson(fileName);\r
 752         JsonSchemaPtr Refparser = std::make_shared<JsonSchema>(json, m_includeResolver);\r
 753 \r
 754         DefinitionsPtr definition = Refparser->getDefinition(defName);\r
 755         if (definition == nullptr)\r
 756             throw JsonException("Definition Name Incorrect");\r
 757 \r
 758         param.addProperties(definition->getProperties());\r
 759         param.addRequired(definition->getRequiredValues());\r
 760         param.setType(definition->getType());\r
 761     }\r
 762 \r
 763     void JsonSchema::readRef(std::string ref ,  JsonParameters &param)\r
 764     {\r
 765         std::string delimiter1 = "#";\r
 766         std::string delimiter2 = "/";\r
 767         std::string fileName;\r
 768         if (! ref.empty())\r
 769         {\r
 770             std::size_t pos = std::string::npos;\r
 771             if ( (pos = ref.find(delimiter1)) != std::string::npos)\r
 772             {\r
 773                 fileName = ref.substr(0, pos);\r
 774                 ref.erase(0, pos);\r
 775             }\r
 776             ref.erase(0, delimiter1 .length());\r
 777             std::string defName;\r
 778 \r
 779             if (! ref.empty())\r
 780             {\r
 781                 ref.erase(0, delimiter2 .length());\r
 782                 std::string keyName;\r
 783                 if ( (pos = ref.find(delimiter2)) != std::string::npos)\r
 784                 {\r
 785                     keyName = ref.substr(0, pos);\r
 786                     ref.erase(0, pos + delimiter2.length());\r
 787                     if (keyName == "definitions")\r
 788                     {\r
 789                         if ( (pos = ref.find(delimiter2)) != std::string::npos)\r
 790                         {\r
 791                             defName = ref.substr(0, pos);\r
 792                         }\r
 793                         else if (! ref.empty())\r
 794                         {\r
 795                             defName = ref;\r
 796                         }\r
 797                     }\r
 798                 }\r
 799             }\r
 800             if (!fileName.empty())\r
 801             {\r
 802                 if (!(defName.empty()))\r
 803                 {\r
 804                     readFile(fileName, defName, param);\r
 805                 }\r
 806                 else\r
 807                 {\r
 808                     throw JsonException("Definition Name Empty");\r
 809                 }\r
 810             }\r
 811             else\r
 812             {\r
 813                 if (!(defName.empty()))\r
 814                 {\r
 815                     if (getDefinition(defName) == nullptr)\r
 816                         throw JsonException("Definition Name Incorrect");\r
 817                     param.addProperties(getDefinition(defName)->getProperties());\r
 818                     param.addRequired(getDefinition(defName)->getRequiredValues());\r
 819                     param.setType(getDefinition(defName)->getType());\r
 820                 }\r
 821                 else\r
 822                 {\r
 823                     throw JsonException("Definition Name Empty");\r
 824                 }\r
 825             }\r
 826         }\r
 827     }\r
 828 \r
 829     void JsonSchema::readJsonRef(cJSON *jsonReference , JsonParameters &param)\r
 830     {\r
 831         std::string ref = jsonReference->valuestring;\r
 832 \r
 833         std::string web = "http://";\r
 834         std::string delimiter = "#";\r
 835         std::size_t pos = ref.find(web);\r
 836 \r
 837         if (pos == std::string::npos)   // If Web Link Is GIVEN TO READ\r
 838         {\r
 839             pos = ref.find(delimiter);\r
 840             if ( pos ==  (ref.length() - 1) )\r
 841             {\r
 842                 std::string fileName = ref.substr(0, pos);\r
 843                 readFile(fileName, param);\r
 844             }\r
 845             else\r
 846             {\r
 847                 readRef(ref, param);\r
 848             }\r
 849         }\r
 850     }\r
 851 \r
 852     void JsonSchema::readAllOf(cJSON *allofValues ,  JsonParameters &allParams)\r
 853     {\r
 854         int size = cJSON_GetArraySize(allofValues);\r
 855         int index = 0;\r
 856         do\r
 857         {\r
 858             JsonParameters param;\r
 859 \r
 860             cJSON *childAllOf = cJSON_GetArrayItem(allofValues, index);\r
 861             cJSON *jsonReference = cJSON_GetObjectItem(childAllOf, "$ref");\r
 862             if (jsonReference)\r
 863             {\r
 864                 readJsonRef(jsonReference, param);\r
 865                 allParams.addProperties(param.getProperties());\r
 866                 allParams.addRequired(param.getRequired());\r
 867                 allParams.setType(param.getType());\r
 868             }\r
 869             cJSON *jsonRequiredValues = cJSON_GetObjectItem(childAllOf, "required");\r
 870             if (jsonRequiredValues)\r
 871             {\r
 872                 int len = cJSON_GetArraySize(jsonRequiredValues);\r
 873                 int idx = 0;\r
 874                 do\r
 875                 {\r
 876                     allParams.addRequired(cJSON_GetArrayItem(jsonRequiredValues, idx)->valuestring);\r
 877                 }\r
 878                 while ( ++idx < len);\r
 879             }\r
 880         }\r
 881         while ( ++index < size);\r
 882     }\r
 883 }\r
 884 \r