service/simulator/ramlparser/raml/jsonSchemaParser/Properties.h

   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   Properties.h\r
  23  *\r
  24  * @brief   This file provides data Model for Json Schema Properties.\r
  25  */\r
  26 \r
  27 #ifndef PROPERTIES_H_\r
  28 #define PROPERTIES_H_\r
  29 \r
  30 #include <string>\r
  31 #include <vector>\r
  32 #include <map>\r
  33 #include <boost/variant.hpp>\r
  34 #include <boost/lexical_cast.hpp>\r
  35 #include <limits>\r
  36 #include "Items.h"\r
  37 #include "AllowedValues.h"\r
  38 #include "cJSON.h"\r
  39 #include <memory>\r
  40 \r
  41 namespace RAML\r
  42 {\r
  43     /**\r
  44      * @class   Properties\r
  45      * @brief   This class provides data Model for Json Schema Properties.\r
  46      */\r
  47     class Properties\r
  48     {\r
  49         public:\r
  50             /**\r
  51                   * Constructor of Properties.\r
  52                   */\r
  53             Properties(): m_min(INT_MAX), m_max(INT_MAX), m_doubleMin(INT_MAX), m_doubleMax(INT_MAX),\r
  54                 m_multipleOf(INT_MAX), m_unique(false), m_additionalItems(false) {}\r
  55 \r
  56             /**\r
  57                   * Constructor of Properties.\r
  58                   *\r
  59                   * @param name - Properties name as string.\r
  60                   */\r
  61             Properties(const std::string &name) : m_name(name), m_min(INT_MAX), m_max(INT_MAX),\r
  62                 m_doubleMin(INT_MAX), m_doubleMax(INT_MAX), m_multipleOf(INT_MAX),\r
  63                 m_unique(false), m_additionalItems(false) {}\r
  64 \r
  65             /**\r
  66                  * This method is for getting Name from Properties.\r
  67                  *\r
  68                  * @return Properties name as string\r
  69                  */\r
  70             inline std::string getName(void) const\r
  71             {\r
  72                 return m_name;\r
  73             }\r
  74 \r
  75             /**\r
  76                  * This method is for setting name to Properties\r
  77                  *\r
  78                  * @param name - Properties name as string.\r
  79                  */\r
  80             inline void setName(const std::string &name)\r
  81             {\r
  82                 m_name = name;\r
  83             }\r
  84 \r
  85             /**\r
  86                  * This method is for getting Value from Properties.\r
  87                  *\r
  88                  * @return Properties Value\r
  89                  */\r
  90             template <typename T>\r
  91             T getValue() const\r
  92             {\r
  93                 return boost::get<T>(m_value);\r
  94             }\r
  95 \r
  96             /**\r
  97                  * This method is for getting Value from Properties.\r
  98                  *\r
  99                  * @return Properties Value\r
 100                  */\r
 101             ValueVariant &getValue()\r
 102             {\r
 103                 return m_value;\r
 104             }\r
 105 \r
 106             /**\r
 107                  * This method is for getting ValueVariant type from Properties.\r
 108                  *\r
 109                  * @return Properties Value type as Int\r
 110                  */\r
 111             int getValueType() const\r
 112             {\r
 113                 return m_value.which();\r
 114             }\r
 115 \r
 116             /**\r
 117                  * This method is for getting ValueVariant type from Properties.\r
 118                  *\r
 119                  * @return Properties VariantType type\r
 120                  */\r
 121             VariantType getVariantType() const\r
 122             {\r
 123                 if (m_value.which() == 3)\r
 124                     return VariantType::STRING;\r
 125                 else if (m_value.which() == 2)\r
 126                     return VariantType::BOOL;\r
 127                 else if (m_value.which() == 1)\r
 128                     return VariantType::DOUBLE;\r
 129                 else\r
 130                     return VariantType::INT;\r
 131             }\r
 132 \r
 133             /**\r
 134                  * This method is for getting Value type as Integer from Properties.\r
 135                  *\r
 136                  * @return Properties Value type as Integer\r
 137                  */\r
 138             int getValueInt()\r
 139             {\r
 140                 return boost::lexical_cast<int> (m_value);\r
 141             }\r
 142 \r
 143             /**\r
 144                  * This method is for getting Value type as String from Properties.\r
 145                  *\r
 146                  * @return Properties Value type as String\r
 147                  */\r
 148             std::string getValueString()\r
 149             {\r
 150                 return boost::lexical_cast<std::string> (m_value);\r
 151             }\r
 152 \r
 153             /**\r
 154                  * This method is for getting Value type as double from Properties.\r
 155                  *\r
 156                  * @return Properties Value type as double\r
 157                  */\r
 158             double getValueDouble()\r
 159             {\r
 160                 return boost::lexical_cast<double> (m_value);\r
 161             }\r
 162 \r
 163             /**\r
 164                  * This method is for getting Value type as bool from Properties.\r
 165                  *\r
 166                  * @return Properties Value type as bool\r
 167                  */\r
 168             bool getValueBool()\r
 169             {\r
 170                 return boost::lexical_cast<bool> (m_value);\r
 171             }\r
 172 \r
 173             /**\r
 174                  * This method is for setting Value to Properties\r
 175                  *\r
 176                  * @param value - Properties Value.\r
 177                  */\r
 178             template <typename T>\r
 179             void setValue(const T &value)\r
 180             {\r
 181                 m_value = value;\r
 182             }\r
 183 \r
 184             /**\r
 185                  * This method is for getting Range from Properties.\r
 186                  *\r
 187                  * @param min - reference to hold Minimum value of Properties.\r
 188                  * @param max -  reference to hold Maximum value of Properties.\r
 189                  * @param multipleOf -  reference to hold multipleOf value of Properties.\r
 190                  */\r
 191             inline void getRange(int &min, int &max, int &multipleOf) const\r
 192             {\r
 193                 min = m_min;\r
 194                 max = m_max;\r
 195                 multipleOf = m_multipleOf;\r
 196             }\r
 197 \r
 198             /**\r
 199                  * This method is for getting Range from Properties.\r
 200                  *\r
 201                  * @param min - reference to hold Minimum value of Properties.\r
 202                  * @param max -  reference to hold Maximum value of Properties.\r
 203                  * @param multipleOf -  reference to hold multipleOf value of Properties.\r
 204                  */\r
 205             inline void getRangeDouble(double &min, double &max, int &multipleOf) const\r
 206             {\r
 207                 min = m_doubleMin;\r
 208                 max = m_doubleMax;\r
 209                 multipleOf = m_multipleOf;\r
 210             }\r
 211             /**\r
 212                  * This method is for setting Minimum to Properties\r
 213                  *\r
 214                  * @param min - Minimum value of Properties.\r
 215                  */\r
 216             inline void setMin(const int &min)\r
 217             {\r
 218                 m_min = min;\r
 219             }\r
 220 \r
 221             /**\r
 222                  * This method is for setting Maximum to Properties\r
 223                  *\r
 224                  * @param max - Maximum value of Properties.\r
 225                  */\r
 226             inline void setMax(const int &max)\r
 227             {\r
 228                 m_max = max;\r
 229             }\r
 230 \r
 231             /**\r
 232                  * This method is for setting Minimum to Properties\r
 233                  *\r
 234                  * @param min - Minimum value of Properties.\r
 235                  */\r
 236             inline void setMinDouble(const double &min)\r
 237             {\r
 238                 m_doubleMin = min;\r
 239             }\r
 240 \r
 241             /**\r
 242                  * This method is for setting Maximum to Properties\r
 243                  *\r
 244                  * @param max - Maximum value of Properties.\r
 245                  */\r
 246             inline void setMaxDouble(const double &max)\r
 247             {\r
 248                 m_doubleMax = max;\r
 249             }\r
 250             /**\r
 251                  * This method is for setting multipleOf to Properties\r
 252                  *\r
 253                  * @param multipleOf - multipleOf value of Properties.\r
 254                  */\r
 255             inline void setMultipleOf(const int &multipleOf)\r
 256             {\r
 257                 m_multipleOf = multipleOf;\r
 258             }\r
 259 \r
 260             /**\r
 261                  * This method is for setting AllowedValues to Properties\r
 262                  *\r
 263                  * @param values - list of AllowedValues of Properties.\r
 264                  */\r
 265             template <typename T>\r
 266             bool setAllowedValues(const std::vector<T> &values)\r
 267             {\r
 268                 ValueVariant temp = values.at(0);\r
 269                 if (temp.which() != m_value.which())\r
 270                 {\r
 271                     return false;\r
 272                 }\r
 273 \r
 274                 m_allowedValues.addValues(values);\r
 275                 return true;\r
 276             }\r
 277 \r
 278             /**\r
 279                  * This method is for getting size of AllowedValues from Properties.\r
 280                  *\r
 281                  * @return  size of AllowedValues\r
 282                  */\r
 283             inline int getAllowedValuesSize() const\r
 284             {\r
 285                 return m_allowedValues.size();\r
 286             }\r
 287 \r
 288             /**\r
 289                  * This method is for getting AllowedValues from Properties.\r
 290                  *\r
 291                  * @return list of AllowedValues of Properties.\r
 292                  */\r
 293             inline std::vector<ValueVariant> getAllowedValues()\r
 294             {\r
 295                 return m_allowedValues.getValues();\r
 296             }\r
 297 \r
 298             /**\r
 299                  * This method is for getting AllowedValues as integer from Properties.\r
 300                  *\r
 301                  * @return list of AllowedValues as integer\r
 302                  */\r
 303             inline std::vector<int> getAllowedValuesInt()\r
 304             {\r
 305                 return m_allowedValues.getValuesInt();\r
 306             }\r
 307 \r
 308             /**\r
 309                  * This method is for getting AllowedValues as String from Properties.\r
 310                  *\r
 311                  * @return list of AllowedValues as String\r
 312                  */\r
 313             inline std::vector<std::string> getAllowedValuesString()\r
 314             {\r
 315                 return m_allowedValues.getValuesString();\r
 316             }\r
 317 \r
 318             /**\r
 319                  * This method is for getting AllowedValues as Double from Properties.\r
 320                  *\r
 321                  * @return list of AllowedValues as Double\r
 322                  */\r
 323             inline std::vector<double> getAllowedValuesDouble()\r
 324             {\r
 325                 return m_allowedValues.getValuesDouble();\r
 326             }\r
 327 \r
 328             /**\r
 329                  * This method is for getting AllowedValues as Bool from Properties.\r
 330                  *\r
 331                  * @return list of AllowedValues as Bool\r
 332                  */\r
 333             inline std::vector<bool> getAllowedValuesBool()\r
 334             {\r
 335                 return m_allowedValues.getValuesBool();\r
 336             }\r
 337 \r
 338             /**\r
 339                  * This method is for setting Description to Properties\r
 340                  *\r
 341                  * @param description - Description as string.\r
 342                  */\r
 343             inline void setDescription(const std::string &description)\r
 344             {\r
 345                 m_description = description;\r
 346             }\r
 347 \r
 348             /**\r
 349                  * This method is for getting Description from Properties.\r
 350                  *\r
 351                  * @return Description as string\r
 352                  */\r
 353             inline std::string getDescription()\r
 354             {\r
 355                 return m_description;\r
 356             }\r
 357 \r
 358             /**\r
 359                  * This method is for setting Type to Properties\r
 360                  *\r
 361                  * @param type - Type as string.\r
 362                  */\r
 363             void setType(const std::string &type)\r
 364             {\r
 365                 m_type = type;\r
 366             }\r
 367 \r
 368             /**\r
 369                  * This method is for getting Type from Properties.\r
 370                  *\r
 371                  * @return Type as string\r
 372                  */\r
 373             std::string getType()\r
 374             {\r
 375                 return m_type;\r
 376             }\r
 377 \r
 378             /**\r
 379                  * This method is for setting Pattern to Properties\r
 380                  *\r
 381                  * @param pattern - Pattern as string.\r
 382                  */\r
 383             void setPattern(const std::string &pattern)\r
 384             {\r
 385                 m_pattern = pattern;\r
 386             }\r
 387 \r
 388 \r
 389             /**\r
 390                  * This method is for getting Pattern from Properties.\r
 391                  *\r
 392                  * @return Pattern as string\r
 393                  */\r
 394             std::string getPattern()\r
 395             {\r
 396                 return m_pattern;\r
 397             }\r
 398 \r
 399             /**\r
 400                  * This method is for setting Format to Properties\r
 401                  *\r
 402                  * @param format - Format as string.\r
 403                  */\r
 404             void setFormat(const std::string &format)\r
 405             {\r
 406                 m_format = format;\r
 407             }\r
 408 \r
 409             /**\r
 410                  * This method is for getting Format from Properties.\r
 411                  *\r
 412                  * @return Format as string\r
 413                  */\r
 414             std::string getFormat()\r
 415             {\r
 416                 return m_format;\r
 417             }\r
 418 \r
 419             /**\r
 420                  * This method is for setting Items to Properties\r
 421                  *\r
 422                  * @param item - pointer to Items\r
 423                  */\r
 424             void setItem(const ItemsPtr &item)\r
 425             {\r
 426                 m_items.push_back(item);\r
 427             }\r
 428 \r
 429             /**\r
 430                  * This method is for getting Items from Properties.\r
 431                  *\r
 432                  * @return list of pointer to Items\r
 433                  */\r
 434             std::vector<ItemsPtr> const &getItems() const\r
 435             {\r
 436                 return m_items;\r
 437             }\r
 438 \r
 439             /**\r
 440                  * This method is for setting Unique to Properties\r
 441                  *\r
 442                  * @param value - Unique as bool\r
 443                  */\r
 444             void setUnique( int value)\r
 445             {\r
 446                 if (value == cJSON_True) m_unique = true;\r
 447                 else m_unique = false;\r
 448             }\r
 449 \r
 450             /**\r
 451                  * This method is for getting isUnique from Properties.\r
 452                  *\r
 453                  * @return isUnique as bool\r
 454                  */\r
 455             bool getUnique()\r
 456             {\r
 457                 return m_unique;\r
 458             }\r
 459 \r
 460             /**\r
 461                  * This method is for setting AdditionalItems to Properties\r
 462                  *\r
 463                  * @param value - AdditionalItems as bool\r
 464                  */\r
 465             void setAdditionalItems(int value)\r
 466             {\r
 467                 if (value == cJSON_True) m_additionalItems = true;\r
 468                 else m_additionalItems = false;\r
 469             }\r
 470 \r
 471             /**\r
 472                  * This method is for getting AdditionalItems from Properties.\r
 473                  *\r
 474                  * @return AdditionalItems as bool\r
 475                  */\r
 476             bool getAdditionalItems()\r
 477             {\r
 478                 return m_additionalItems;\r
 479             }\r
 480         private:\r
 481             std::string m_name;\r
 482             ValueVariant m_value;\r
 483             int m_min;\r
 484             int m_max;\r
 485             double m_doubleMin;\r
 486             double m_doubleMax;\r
 487             int m_multipleOf;\r
 488             AllowedValues m_allowedValues;\r
 489             std::string m_type;\r
 490             std::string m_pattern;\r
 491             std::string m_format;\r
 492             std::string m_description;\r
 493             bool m_unique;\r
 494             bool m_additionalItems;\r
 495             std::vector<ItemsPtr > m_items;\r
 496     };\r
 497 \r
 498     /** PropertiesPtr - shared Ptr to Properties.*/\r
 499     typedef std::shared_ptr<Properties> PropertiesPtr;\r
 500 \r
 501 }\r
 502 #endif\r