service/simulator/ramlparser/raml/model/AbstractParam.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 #include "AbstractParam.h"\r
  22 \r
  23 \r
  24 namespace RAML\r
  25 {\r
  26     std::string AbstractParam::getDefaultValue() const\r
  27     {\r
  28         return m_defaultValue;\r
  29     }\r
  30     void AbstractParam::setDefaultValue(const std::string &defaultValue)\r
  31     {\r
  32         m_defaultValue = defaultValue;\r
  33     }\r
  34 \r
  35     std::string AbstractParam::getDescription() const\r
  36     {\r
  37         return m_description;\r
  38     }\r
  39 \r
  40     void AbstractParam::setDescription(const std::string &description)\r
  41     {\r
  42         m_description = description;\r
  43     }\r
  44 \r
  45     std::string AbstractParam::getDisplayName() const\r
  46     {\r
  47         return m_displayName;\r
  48     }\r
  49 \r
  50     void AbstractParam::setDisplayName(const std::string &displayName)\r
  51     {\r
  52         m_displayName = displayName;\r
  53     }\r
  54 \r
  55     std::list<std::string> AbstractParam::getEnumeration() const\r
  56     {\r
  57         return m_enumeration;\r
  58     }\r
  59 \r
  60     void AbstractParam::setEnumeration(const std::string &enumeration)\r
  61     {\r
  62         m_enumeration.push_back(enumeration);\r
  63     }\r
  64 \r
  65     std::string AbstractParam::getExample() const\r
  66     {\r
  67         return m_example;\r
  68     }\r
  69 \r
  70     void AbstractParam::setExample(const std::string &example)\r
  71     {\r
  72         m_example = example;\r
  73     }\r
  74 \r
  75     int AbstractParam::getMaxLength() const\r
  76     {\r
  77         return m_maxLength;\r
  78     }\r
  79 \r
  80     void AbstractParam::setMaxLength(int maxLength)\r
  81     {\r
  82         m_maxLength = maxLength;\r
  83     }\r
  84 \r
  85     int AbstractParam::getMaximum() const\r
  86     {\r
  87         return m_maximum;\r
  88     }\r
  89 \r
  90     void AbstractParam::setMaximum(int maximum)\r
  91     {\r
  92         m_maximum = maximum;\r
  93     }\r
  94 \r
  95     int AbstractParam::getMinLength() const\r
  96     {\r
  97         return m_minLength;\r
  98     }\r
  99 \r
 100     void AbstractParam::setMinLength(int minLength)\r
 101     {\r
 102         m_minLength = minLength;\r
 103     }\r
 104 \r
 105     int AbstractParam::getMinimum() const\r
 106     {\r
 107         return m_minimum;\r
 108     }\r
 109 \r
 110     void AbstractParam::setMinimum(int minimum)\r
 111     {\r
 112         m_minimum = minimum;\r
 113     }\r
 114 \r
 115     std::string AbstractParam::getPattern() const\r
 116     {\r
 117         return m_pattern;\r
 118     }\r
 119 \r
 120     void AbstractParam::setPattern(const std::string &pattern)\r
 121     {\r
 122         m_pattern = pattern;\r
 123     }\r
 124 \r
 125     std::string AbstractParam::getType() const\r
 126     {\r
 127         return m_type;\r
 128     }\r
 129 \r
 130     void AbstractParam::setType(const std::string &type)\r
 131     {\r
 132         m_type = type;\r
 133     }\r
 134 \r
 135     bool AbstractParam::isRepeat() const\r
 136     {\r
 137         return m_repeat;\r
 138     }\r
 139 \r
 140     void AbstractParam::setRepeat(bool repeat)\r
 141     {\r
 142         m_repeat = repeat;\r
 143     }\r
 144 \r
 145     bool AbstractParam::isRequired() const\r
 146     {\r
 147         return m_required;\r
 148     }\r
 149 \r
 150     void AbstractParam::setRequired(bool required)\r
 151     {\r
 152         m_required = required;\r
 153     }\r
 154 \r
 155     void AbstractParam::readParameters(const YAML::Node &yamlNode)\r
 156     {\r
 157         for ( YAML::const_iterator it = yamlNode.begin(); it != yamlNode.end(); ++it )\r
 158         {\r
 159             std::string key = READ_NODE_AS_STRING(it->first);\r
 160 \r
 161             if (key == Keys::Description)\r
 162                 setDescription(READ_NODE_AS_STRING(it->second));\r
 163             else if (key == Keys::Default)\r
 164                 setDefaultValue(READ_NODE_AS_STRING(it->second));\r
 165             else if (key == Keys::DisplayName)\r
 166                 setDisplayName(READ_NODE_AS_STRING(it->second));\r
 167 \r
 168             else if (key == Keys::Example)\r
 169                 setExample(READ_NODE_AS_STRING(it->second));\r
 170             else if (key == Keys::Maximum)\r
 171                 setMaximum(READ_NODE_AS_LONG(it->second));\r
 172             else if (key == Keys::Minimum)\r
 173                 setMinimum(READ_NODE_AS_LONG(it->second));\r
 174             else if (key == Keys::MaxLength)\r
 175                 setMaxLength(READ_NODE_AS_INT(it->second));\r
 176             else if (key == Keys::MinLength)\r
 177                 setMinLength(READ_NODE_AS_INT(it->second));\r
 178 \r
 179             else if (key == Keys::Pattern)\r
 180                 setPattern(READ_NODE_AS_STRING(it->second));\r
 181             else if (key == Keys::Repeat)\r
 182                 setRepeat(READ_NODE_AS_BOOL(it->second));\r
 183             else if (key == Keys::Required)\r
 184                 setRequired(READ_NODE_AS_BOOL(it->second));\r
 185             else if (key == Keys::Type)\r
 186                 setType(READ_NODE_AS_STRING(it->second));\r
 187             else if (key == Keys::Enum)\r
 188             {\r
 189                 YAML::Node enumNode = it->second;\r
 190                 for ( YAML::const_iterator tt = enumNode.begin(); tt != enumNode.end(); ++tt )\r
 191                     setEnumeration(READ_NODE_AS_STRING(*tt));\r
 192             }\r
 193         }\r
 194     }\r
 195 }\r