1 /******************************************************************
\r
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
\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
11 * http://www.apache.org/licenses/LICENSE-2.0
\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
19 ******************************************************************/
\r
21 #include "JsonSchema.h"
\r
22 using namespace std;
\r
27 void JsonSchema::readJson()
\r
32 cJSON *jsonId = cJSON_GetObjectItem(m_cjson, "id");
\r
35 m_id = jsonId->valuestring;
\r
37 cJSON *jsonSchema = cJSON_GetObjectItem(m_cjson, "$schema");
\r
40 m_schema = jsonSchema->valuestring;
\r
42 cJSON *jsonTitle = cJSON_GetObjectItem(m_cjson, "title");
\r
45 m_title = jsonTitle->valuestring;
\r
47 cJSON *jsonType = cJSON_GetObjectItem(m_cjson, "type");
\r
50 m_type = jsonType->valuestring;
\r
52 cJSON *jsonDescription = cJSON_GetObjectItem(m_cjson, "description");
\r
53 if (jsonDescription)
\r
55 m_description = jsonDescription->valuestring;
\r
57 cJSON *jsonDefinitions = cJSON_GetObjectItem(m_cjson, "definitions");
\r
58 if (jsonDefinitions)
\r
60 cJSON *childDefinitions = jsonDefinitions->child;
\r
61 while (childDefinitions)
\r
63 std::string defName = childDefinitions->string;
\r
64 addDefinition(defName, readDef(childDefinitions, defName));
\r
65 childDefinitions = childDefinitions->next;
\r
68 cJSON *jsonProperties = cJSON_GetObjectItem(m_cjson, "properties");
\r
71 cJSON *childProperties = jsonProperties->child;
\r
72 while (childProperties)
\r
74 std::string attName = childProperties->string;
\r
75 addProperty(attName, readProp(childProperties, attName));
\r
76 childProperties = childProperties->next;
\r
79 if (m_type == "array")
\r
81 cJSON *jsonItems = cJSON_GetObjectItem(m_cjson, "items");
\r
84 if (jsonItems->type == 5)
\r
86 int item_size = cJSON_GetArraySize(jsonItems);
\r
90 cJSON *item = cJSON_GetArrayItem(jsonItems, item_index);
\r
91 setItem(readItems(item));
\r
93 while ( ++item_index < item_size);
\r
97 setItem(readItems(jsonItems));
\r
101 cJSON *jsonAdditionalProperties = cJSON_GetObjectItem(m_cjson, "additionalProperties");
\r
102 if (jsonAdditionalProperties)
\r
103 m_additionalProperties = jsonAdditionalProperties->type;
\r
105 m_additionalProperties = cJSON_True;
\r
107 cJSON *jsonReference = cJSON_GetObjectItem(m_cjson, "$ref");
\r
110 readJsonRef(jsonReference);
\r
112 cJSON *jsonAllOf = cJSON_GetObjectItem(m_cjson, "allOf");
\r
115 readAllOf(jsonAllOf);
\r
117 cJSON *jsonRequiredValues = cJSON_GetObjectItem(m_cjson, "required");
\r
118 if (jsonRequiredValues)
\r
120 int size = cJSON_GetArraySize(jsonRequiredValues);
\r
124 setRequiredValue(cJSON_GetArrayItem(jsonRequiredValues, index)->valuestring);
\r
126 while ( ++index < size);
\r
130 DefinitionsPtr JsonSchema::readDef(cJSON *childDefinitions, const std::string &defName)
\r
132 DefinitionsPtr definition = std::make_shared<Definitions>(defName);
\r
134 cJSON *defType = cJSON_GetObjectItem(childDefinitions, "type");
\r
137 std::string type = defType->valuestring;
\r
138 definition->setType(type);
\r
140 cJSON *defProperties = cJSON_GetObjectItem(childDefinitions, "properties");
\r
143 cJSON *childProperties = defProperties->child;
\r
144 while (childProperties)
\r
146 std::string attName = childProperties->string;
\r
147 definition->addProperty(attName, readProp(childProperties, attName));
\r
148 childProperties = childProperties->next;
\r
151 cJSON *defRequiredValues = cJSON_GetObjectItem(childDefinitions, "required");
\r
152 if (defRequiredValues)
\r
154 int size = cJSON_GetArraySize(defRequiredValues);
\r
158 definition->setRequiredValue(cJSON_GetArrayItem(defRequiredValues, index)->valuestring);
\r
160 while ( ++index < size);
\r
162 cJSON *defReference = cJSON_GetObjectItem(childDefinitions, "$ref");
\r
165 readDefRef(defReference, definition);
\r
167 cJSON *defAllOf = cJSON_GetObjectItem(childDefinitions, "allOf");
\r
170 readDefAllOf(defAllOf, definition);
\r
175 PropertiesPtr JsonSchema::readProp(cJSON *childProperties, const std::string &attName )
\r
177 PropertiesPtr property = std::make_shared<Properties>(attName);
\r
179 cJSON *propertyDescription = cJSON_GetObjectItem(childProperties, "description");
\r
180 if (propertyDescription)
\r
182 property->setDescription(propertyDescription->valuestring);
\r
184 cJSON *propertyType = cJSON_GetObjectItem(childProperties, "type");
\r
187 std::string attType;
\r
188 if (propertyType->type == 4)
\r
190 attType = propertyType->valuestring;
\r
191 property->setType(attType);
\r
193 else if (propertyType->type == 5)
\r
195 attType = cJSON_GetArrayItem(propertyType, 0)->valuestring;
\r
196 property->setType(attType);
\r
198 readValues(childProperties, property, attType);
\r
200 cJSON *defaultValue = cJSON_GetObjectItem(childProperties, "default");
\r
203 if (defaultValue->type == 4)
\r
205 property->setValue((std::string)defaultValue->valuestring);
\r
207 else if (defaultValue->type == 3)
\r
209 if (property->getType() == "number")
\r
210 property->setValue((double)defaultValue->valuedouble);
\r
212 property->setValue((int)defaultValue->valueint );
\r
214 else if (defaultValue->type == 1)
\r
216 property->setValue((bool)true);
\r
218 else if (defaultValue->type == 0)
\r
220 property->setValue((bool)false);
\r
224 cJSON *allowedvalues = cJSON_GetObjectItem(childProperties, "enum");
\r
227 if ((cJSON_GetArrayItem(allowedvalues, 0)->type) == 4)
\r
229 int size = cJSON_GetArraySize(allowedvalues);
\r
231 std::vector<std::string> allwdValues;
\r
234 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valuestring);
\r
236 while ( ++idx < size);
\r
237 property->setAllowedValues(allwdValues);
\r
239 else if ((cJSON_GetArrayItem(allowedvalues, 0)->type) == 3)
\r
241 int size = cJSON_GetArraySize(allowedvalues);
\r
243 if (property->getType() == "number")
\r
245 std::vector<double> allwdValues;
\r
248 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valuedouble);
\r
250 while ( ++idx < size);
\r
251 property->setAllowedValues(allwdValues);
\r
255 std::vector<int> allwdValues;
\r
258 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valueint);
\r
260 while ( ++idx < size);
\r
261 property->setAllowedValues(allwdValues);
\r
264 else if (((cJSON_GetArrayItem(allowedvalues, 0)->type) == 1)
\r
265 || ((cJSON_GetArrayItem(allowedvalues, 0)->type) == 0))
\r
267 int size = cJSON_GetArraySize(allowedvalues);
\r
269 std::vector<bool> allwdValues;
\r
272 if (cJSON_GetArrayItem(allowedvalues, idx)->type)
\r
273 allwdValues.push_back(true);
\r
275 allwdValues.push_back(false);
\r
277 while ( ++idx < size);
\r
278 property->setAllowedValues(allwdValues);
\r
284 void JsonSchema::readValues(cJSON *childProperties, PropertiesPtr property ,
\r
285 const std::string &attType)
\r
287 if (attType == "string")
\r
289 readString(childProperties, property);
\r
291 else if (attType == "integer")
\r
293 readInteger(childProperties, property);
\r
295 else if (attType == "array")
\r
297 readArray(childProperties, property);
\r
299 else if (attType == "number")
\r
301 readDouble(childProperties, property);
\r
305 void JsonSchema::readString(cJSON *childProperties, PropertiesPtr property)
\r
307 cJSON *stringMax = cJSON_GetObjectItem(childProperties, "maxLength");
\r
310 cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");
\r
313 if (exclusiveMax->type == cJSON_True)
\r
314 property->setMax (--(stringMax->valueint));
\r
316 property->setMax(stringMax->valueint);
\r
319 property->setMax(stringMax->valueint);
\r
321 cJSON *stringMin = cJSON_GetObjectItem(childProperties, "minLength");
\r
324 cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");
\r
327 if (exclusiveMin->type == cJSON_True)
\r
328 property->setMin( ++(stringMin->valueint));
\r
330 property->setMin(stringMin->valueint);
\r
333 property->setMin(stringMin->valueint);
\r
335 cJSON *stringFormat = cJSON_GetObjectItem(childProperties, "format");
\r
338 property->setFormat(stringFormat->valuestring);
\r
340 cJSON *stringPattern = cJSON_GetObjectItem(childProperties, "pattern");
\r
343 property->setPattern(stringPattern->valuestring);
\r
347 void JsonSchema::readArray(cJSON *childProperties, PropertiesPtr property)
\r
349 cJSON *itemValues = cJSON_GetObjectItem(childProperties, "items");
\r
352 if (itemValues->type == 5)
\r
354 int item_size = cJSON_GetArraySize(itemValues);
\r
355 int item_index = 0;
\r
358 cJSON *item = cJSON_GetArrayItem(itemValues, item_index);
\r
359 property->setItem(readItems(item));
\r
361 while ( ++item_index < item_size);
\r
365 property->setItem(readItems(itemValues));
\r
368 cJSON *itemsMax = cJSON_GetObjectItem(childProperties, "maxItems");
\r
371 cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");
\r
374 if (exclusiveMax->type == cJSON_True)
\r
375 property->setMax( --(itemsMax->valueint));
\r
377 property->setMax(itemsMax->valueint);
\r
380 property->setMax(itemsMax->valueint);
\r
382 cJSON *itemsMin = cJSON_GetObjectItem(childProperties, "minLength");
\r
385 cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");
\r
388 if (exclusiveMin->type == cJSON_True)
\r
389 property->setMin( ++(itemsMin->valueint));
\r
391 property->setMin(itemsMin->valueint);
\r
394 property->setMin(itemsMin->valueint);
\r
396 cJSON *uniqueItems = cJSON_GetObjectItem(childProperties, "uniqueItems");
\r
399 property->setUnique(uniqueItems->type);
\r
403 property->setUnique(cJSON_True);
\r
405 cJSON *additionalItems = cJSON_GetObjectItem(childProperties, "additionalItems");
\r
406 if (additionalItems)
\r
408 property->setAdditionalItems(additionalItems->type);
\r
412 property->setAdditionalItems(cJSON_True);
\r
416 void JsonSchema::readInteger(cJSON *childProperties, PropertiesPtr property)
\r
418 cJSON *Max = cJSON_GetObjectItem(childProperties, "maximum");
\r
421 cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");
\r
424 if (exclusiveMax->type == cJSON_True)
\r
425 property->setMax( --(Max->valueint));
\r
427 property->setMax(Max->valueint);
\r
430 property->setMax(Max->valueint);
\r
432 cJSON *Min = cJSON_GetObjectItem(childProperties, "minimum");
\r
435 cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");
\r
438 if (exclusiveMin->type == cJSON_True)
\r
439 property->setMin( ++(Min->valueint));
\r
441 property->setMin(Min->valueint);
\r
444 property->setMin(Min->valueint);
\r
446 cJSON *multipleOf = cJSON_GetObjectItem(childProperties, "multipleOf");
\r
449 property->setMultipleOf(multipleOf->valueint);
\r
454 void JsonSchema::readDouble(cJSON *childProperties, PropertiesPtr property)
\r
456 cJSON *Max = cJSON_GetObjectItem(childProperties, "maximum");
\r
459 cJSON *exclusiveMax = cJSON_GetObjectItem(childProperties, "exclusiveMaximum");
\r
462 if (exclusiveMax->type == cJSON_True)
\r
463 property->setMaxDouble( --(Max->valuedouble));
\r
465 property->setMaxDouble(Max->valuedouble);
\r
468 property->setMaxDouble(Max->valuedouble);
\r
470 cJSON *Min = cJSON_GetObjectItem(childProperties, "minimum");
\r
473 cJSON *exclusiveMin = cJSON_GetObjectItem(childProperties, "exclusiveMinimum");
\r
476 if (exclusiveMin->type == cJSON_True)
\r
477 property->setMinDouble( ++(Min->valuedouble));
\r
479 property->setMinDouble(Min->valuedouble);
\r
482 property->setMinDouble(Min->valuedouble);
\r
484 cJSON *multipleOf = cJSON_GetObjectItem(childProperties, "multipleOf");
\r
487 property->setMultipleOf(multipleOf->valueint);
\r
492 DefinitionsPtr JsonSchema::readRef(std::string m_ref)
\r
494 std::string delimiter1 = "#";
\r
495 std::string delimiter2 = "/";
\r
496 std::string fileName;
\r
497 if (! m_ref.empty())
\r
499 std::size_t pos = m_ref.find(delimiter1);
\r
500 if ( (pos = m_ref.find(delimiter1)) != std::string::npos)
\r
502 fileName = m_ref.substr(0, pos);
\r
503 m_ref.erase(0, pos);
\r
505 m_ref.erase(0, delimiter1 .length());
\r
506 std::string defName;
\r
508 if (! m_ref.empty())
\r
510 m_ref.erase(0, delimiter2 .length());
\r
511 std::string keyName;
\r
512 if ( (pos = m_ref.find(delimiter2)) != std::string::npos)
\r
514 keyName = m_ref.substr(0, pos);
\r
515 m_ref.erase(0, pos + delimiter2.length());
\r
516 if (keyName == "definitions")
\r
518 if ( (pos = m_ref.find(delimiter2)) != std::string::npos)
\r
520 defName = m_ref.substr(0, pos);
\r
522 else if (! m_ref.empty())
\r
529 if (!fileName.empty())
\r
531 if (!(defName.empty()))
\r
533 cJSON *m_json = m_includeResolver->readToJson(fileName);
\r
534 JsonSchemaPtr Refparser = std::make_shared<JsonSchema>(m_json, m_includeResolver);
\r
535 DefinitionsPtr definition = Refparser->getDefinition(defName);
\r
536 if (definition == nullptr)
\r
537 throw JsonException("Definition Name Incorrect");
\r
543 if (!(defName.empty()))
\r
545 if (getDefinition(defName) == nullptr)
\r
546 throw JsonException("Definition Name Incorrect");
\r
547 return getDefinition(defName);
\r
551 throw JsonException("Definition Name Empty");
\r
554 void JsonSchema::readAllOf(cJSON *allofValues)
\r
556 int size = cJSON_GetArraySize(allofValues);
\r
560 cJSON *childAllOf = cJSON_GetArrayItem(allofValues, index);
\r
561 cJSON *jsonReference = cJSON_GetObjectItem(childAllOf, "$ref");
\r
564 readJsonRef(jsonReference );
\r
566 cJSON *jsonRequiredValues = cJSON_GetObjectItem(childAllOf, "required");
\r
567 if (jsonRequiredValues)
\r
569 int len = cJSON_GetArraySize(jsonRequiredValues);
\r
573 setRequiredValue(cJSON_GetArrayItem(jsonRequiredValues, idx)->valuestring);
\r
575 while ( ++idx < len);
\r
578 while ( ++index < size);
\r
580 void JsonSchema::readJsonRef(cJSON *jsonReference)
\r
582 std::string m_ref = jsonReference->valuestring;
\r
583 std::map<std::string, PropertiesPtr > properties;
\r
584 std::vector<std::string> required;
\r
586 std::string web = "http://";
\r
587 std::string delimiter = "#";
\r
588 std::size_t pos = m_ref.find(web);
\r
590 if (pos == std::string::npos) // If Web Link Is GIVEN TO READ
\r
592 pos = m_ref.find(delimiter);
\r
593 if ( pos == (m_ref.length() - 1) )
\r
595 std::string fileName = m_ref.substr(0, pos);
\r
596 cJSON *m_json = m_includeResolver->readToJson(fileName);
\r
597 JsonSchemaPtr Refparser = std::make_shared<JsonSchema>(m_json, m_includeResolver);
\r
599 properties = Refparser->getProperties();
\r
600 required = Refparser->getRequiredValues();
\r
604 DefinitionsPtr definition = readRef(m_ref);
\r
605 properties = definition->getProperties();
\r
606 required = definition->getRequiredValues();
\r
608 for ( auto it : properties)
\r
610 std:: string name = it.first;
\r
611 addProperty(name, it.second);
\r
613 for (auto it : required )
\r
615 setRequiredValue(it);
\r
620 void JsonSchema::readDefAllOf(cJSON *allofValues, DefinitionsPtr definition)
\r
622 int size = cJSON_GetArraySize(allofValues);
\r
626 cJSON *childAllOf = cJSON_GetArrayItem(allofValues, index);
\r
627 cJSON *defReference = cJSON_GetObjectItem(childAllOf, "$ref");
\r
630 readDefRef(defReference , definition);
\r
632 cJSON *defRequiredValues = cJSON_GetObjectItem(allofValues, "required");
\r
633 if (defRequiredValues)
\r
635 int len = cJSON_GetArraySize(defRequiredValues);
\r
639 definition->setRequiredValue(cJSON_GetArrayItem(defRequiredValues, idx)->valuestring);
\r
641 while ( ++idx < len);
\r
644 while ( ++index < size);
\r
646 void JsonSchema::readDefRef(cJSON *defReference, DefinitionsPtr definition)
\r
648 std::string m_ref = defReference->valuestring;
\r
649 std::map<std::string, PropertiesPtr > properties;
\r
650 std::vector<std::string> required;
\r
653 std::string web = "http://";
\r
654 std::string delimiter = "#";
\r
655 std::size_t pos = m_ref.find(web);
\r
657 if (pos == std::string::npos) // If Web Link Is GIVEN TO READ
\r
659 pos = m_ref.find(delimiter);
\r
660 if ( pos == (m_ref.length() - 1) )
\r
662 std::string fileName = m_ref.substr(0, pos);
\r
663 cJSON *m_json = m_includeResolver->readToJson(fileName);
\r
664 JsonSchemaPtr Refparser = std::make_shared<JsonSchema>(m_json, m_includeResolver);
\r
666 properties = Refparser->getProperties();
\r
667 required = Refparser->getRequiredValues();
\r
668 type = Refparser->getType();
\r
672 DefinitionsPtr definitionRef = readRef(m_ref);
\r
673 properties = definitionRef->getProperties();
\r
674 required = definitionRef->getRequiredValues();
\r
675 type = definitionRef->getType();
\r
677 for (auto it : properties)
\r
679 definition->addProperty(it.first, it.second);
\r
681 for ( auto it : required)
\r
683 definition->setRequiredValue(it);
\r
685 definition->setType(type);
\r
688 ItemsPtr JsonSchema::readItems(cJSON *item)
\r
690 ItemsPtr newItem = std::make_shared<Items>();
\r
691 cJSON *itemType = cJSON_GetObjectItem(item, "type");
\r
694 std::string type = itemType->valuestring;
\r
695 newItem->setType(type);
\r
698 cJSON *itemProperties = cJSON_GetObjectItem(item, "properties");
\r
699 if (itemProperties)
\r
701 cJSON *childProperties = itemProperties->child;
\r
702 while (childProperties)
\r
704 std::string attName = childProperties->string;
\r
706 newItem->addProperty(attName, readProp(childProperties, attName));
\r
707 childProperties = childProperties->next;
\r
711 cJSON *allowedvalues = cJSON_GetObjectItem(item, "enum");
\r
714 if ((cJSON_GetArrayItem(allowedvalues, 0)->type) == 4)
\r
716 int size = cJSON_GetArraySize(allowedvalues);
\r
718 std::vector<std::string> allwdValues;
\r
721 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valuestring);
\r
723 while ( ++idx < size);
\r
724 newItem->setAllowedValues(allwdValues);
\r
726 else if ((cJSON_GetArrayItem(allowedvalues, 0)->type) == 3)
\r
728 int size = cJSON_GetArraySize(allowedvalues);
\r
730 if (newItem->getType() == "number")
\r
732 std::vector<double> allwdValues;
\r
735 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valuedouble);
\r
737 while ( ++idx < size);
\r
738 newItem->setAllowedValues(allwdValues);
\r
742 std::vector<int> allwdValues;
\r
745 allwdValues.push_back(cJSON_GetArrayItem(allowedvalues, idx)->valueint);
\r
747 while ( ++idx < size);
\r
748 newItem->setAllowedValues(allwdValues);
\r
751 else if (((cJSON_GetArrayItem(allowedvalues, 0)->type) == 1)
\r
752 || ((cJSON_GetArrayItem(allowedvalues, 0)->type) == 0))
\r
754 int size = cJSON_GetArraySize(allowedvalues);
\r
756 std::vector<bool> allwdValues;
\r
759 if (cJSON_GetArrayItem(allowedvalues, idx)->type)
\r
760 allwdValues.push_back(true);
\r
762 allwdValues.push_back(false);
\r
764 while ( ++idx < size);
\r
765 newItem->setAllowedValues(allwdValues);
\r
768 cJSON *itemRequiredValues = cJSON_GetObjectItem(item, "required");
\r
769 if (itemRequiredValues)
\r
771 int size = cJSON_GetArraySize(itemRequiredValues);
\r
775 newItem->setRequiredValue(cJSON_GetArrayItem(itemRequiredValues, index)->valuestring);
\r
777 while ( ++index < size);
\r
779 cJSON *itemReference = cJSON_GetObjectItem(item, "$ref");
\r
782 readItemRef(itemReference , newItem);
\r
784 cJSON *itemAllOf = cJSON_GetObjectItem(item, "allOf");
\r
787 readItemAllOf(itemAllOf , newItem);
\r
792 void JsonSchema::readItemRef(cJSON *itemReference, ItemsPtr item)
\r
794 std::string m_ref = itemReference->valuestring;
\r
795 std::map<std::string, PropertiesPtr > properties;
\r
796 std::vector<std::string> required;
\r
799 std::string web = "http://";
\r
800 std::string delimiter = "#";
\r
801 std::size_t pos = m_ref.find(web);
\r
803 if (pos == std::string::npos) // If Web Link Is GIVEN TO READ
\r
805 pos = m_ref.find(delimiter);
\r
806 if ( pos == (m_ref.length() - 1 ) )
\r
808 std::string fileName = m_ref.substr(0, pos);
\r
809 cJSON *m_json = m_includeResolver->readToJson(fileName);
\r
810 JsonSchemaPtr Refparser = std::make_shared<JsonSchema>(m_json, m_includeResolver);
\r
812 properties = Refparser->getProperties();
\r
813 required = Refparser->getRequiredValues();
\r
814 type = Refparser->getType();
\r
818 DefinitionsPtr definitionRef = readRef(m_ref);
\r
819 properties = definitionRef->getProperties();
\r
820 required = definitionRef->getRequiredValues();
\r
821 type = definitionRef->getType();
\r
823 for ( auto it : properties)
\r
825 std:: string name = it.first;
\r
826 item->addProperty(name, it.second);
\r
828 for ( auto it : required)
\r
830 item->setRequiredValue(it);
\r
832 item->setType(type);
\r
836 void JsonSchema::readItemAllOf(cJSON *allofValues, ItemsPtr item)
\r
838 int size = cJSON_GetArraySize(allofValues);
\r
842 cJSON *childAllOf = cJSON_GetArrayItem(allofValues, index);
\r
843 cJSON *itemReference = cJSON_GetObjectItem(childAllOf, "$ref");
\r
846 readItemRef(itemReference, item);
\r
848 cJSON *itemRequiredValues = cJSON_GetObjectItem(allofValues, "required");
\r
849 if (itemRequiredValues)
\r
851 int len = cJSON_GetArraySize(itemRequiredValues);
\r
855 item->setRequiredValue(cJSON_GetArrayItem(itemRequiredValues, idx)->valuestring);
\r
857 while ( ++idx < len);
\r
860 while ( ++index < size);
\r