service/simulator/ramlparser/raml/model/Raml.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 "Raml.h"\r
  22 \r
  23 namespace RAML\r
  24 {\r
  25 \r
  26     std::string Raml::getTitle() const\r
  27     {\r
  28         return m_title;\r
  29     }\r
  30     void Raml::setTitle(const std::string &title)\r
  31     {\r
  32         m_title = title;\r
  33     }\r
  34 \r
  35     std::string Raml::getVersion() const\r
  36     {\r
  37         return m_version;\r
  38     }\r
  39     void Raml::setVersion(const std::string &version)\r
  40     {\r
  41         m_version = version;\r
  42     }\r
  43 \r
  44     std::string Raml::getBaseUri() const\r
  45     {\r
  46         return m_baseUri;\r
  47     }\r
  48     void Raml::setBaseUri(const std::string &baseUri)\r
  49     {\r
  50         m_baseUri = baseUri;\r
  51     }\r
  52 \r
  53     std::list<std::string> Raml::getProtocols() const\r
  54     {\r
  55         return m_protocols;\r
  56     }\r
  57     void Raml::setProtocol(const std::string &protocol)\r
  58     {\r
  59         m_protocols.push_back(protocol);\r
  60     }\r
  61     std::map<std::string, UriParameter> Raml::getBaseUriParameters() const\r
  62     {\r
  63         return m_baseUriParameters;\r
  64     }\r
  65     void Raml::setBaseUriParameter(const std::string &paramName, const UriParameter &uriParameter)\r
  66     {\r
  67         m_baseUriParameters[paramName] = uriParameter;\r
  68     }\r
  69 \r
  70     std::string Raml::getMediaType() const\r
  71     {\r
  72         return m_mediaType;\r
  73     }\r
  74     void Raml::setMediaType(const std::string &mediaType)\r
  75     {\r
  76         m_mediaType = mediaType;\r
  77     }\r
  78 \r
  79     std::list<std::pair<std::string, Schema> > Raml::getSchemas() const\r
  80     {\r
  81         return m_schemas;\r
  82     }\r
  83 \r
  84     void Raml::setSchema(const std::pair<std::string, Schema> &schema)\r
  85     {\r
  86         m_schemas.push_back(schema);\r
  87     }\r
  88 \r
  89     std::list<std::pair<std::string, RamlResource> > Raml::getResourceTypes() const\r
  90     {\r
  91         return m_resourceTypes;\r
  92     }\r
  93     void Raml::setResourceType(const std::pair<std::string, RamlResource> &resourceType)\r
  94     {\r
  95         m_resourceTypes.push_back(resourceType);\r
  96     }\r
  97 \r
  98     std::list<std::pair<std::string, Action> > Raml::getTraits() const\r
  99     {\r
 100         return m_traits;\r
 101     }\r
 102     void Raml::setTrait(const std::pair<std::string, Action> &trait)\r
 103     {\r
 104         m_traits.push_back(trait);\r
 105     }\r
 106     RamlResource &Raml::getResource(std::string resourceName)\r
 107     {\r
 108         return m_resources[resourceName];\r
 109     }\r
 110 \r
 111     std::map<std::string, RamlResource> Raml::getResources() const\r
 112     {\r
 113         return m_resources;\r
 114     }\r
 115 \r
 116     void Raml::setResource(const std::string &resourceKey, const RamlResource &resource)\r
 117     {\r
 118         m_resources[resourceKey] = resource;\r
 119     }\r
 120 \r
 121     void Raml::setDocumentationItem(const DocumentationItem &documentationItem)\r
 122     {\r
 123         m_documentation.push_back(documentationItem);\r
 124     }\r
 125 \r
 126     std::list<DocumentationItem> Raml::getDocumentation() const\r
 127     {\r
 128         return m_documentation;\r
 129     }\r
 130     void Raml::readRamlFromYaml(const YAML::Node &yamlNode )\r
 131     {\r
 132         if (yamlNode.Type() == YAML::NodeType::Map)\r
 133         {\r
 134             for ( YAML::const_iterator it = yamlNode.begin(); it != yamlNode.end(); ++it )\r
 135             {\r
 136                 std::string key = READ_NODE_AS_STRING(it->first);\r
 137                 if (key == Keys::Title)\r
 138                 {\r
 139                     setTitle(READ_NODE_AS_STRING(it->second));\r
 140                 }\r
 141                 else if (key == Keys::Version)\r
 142                 {\r
 143                     setVersion(READ_NODE_AS_STRING(it->second));\r
 144                 }\r
 145                 else if (key == Keys::BaseUri)\r
 146                 {\r
 147                     setBaseUri(READ_NODE_AS_STRING(it->second));\r
 148                 }\r
 149                 else if ((key == Keys::BaseUriParameters) || (key == Keys::UriParameters))\r
 150                 {\r
 151                     YAML::Node paramNode = it->second;\r
 152                     for ( YAML::const_iterator tt = paramNode.begin(); tt != paramNode.end(); ++tt )\r
 153                     {\r
 154                         UriParameter *uriParameter = new UriParameter(tt->second);\r
 155                         setBaseUriParameter(READ_NODE_AS_STRING(tt->first), *uriParameter);\r
 156                     }\r
 157                 }\r
 158                 else if (key == Keys::Protocols)\r
 159                 {\r
 160                     YAML::Node protocolNode = it->second;\r
 161                     for ( YAML::const_iterator tt = protocolNode.begin(); tt != protocolNode.end(); ++tt )\r
 162                     {\r
 163                         setProtocol(READ_NODE_AS_STRING(*tt));\r
 164                     }\r
 165                 }\r
 166                 else if (key == Keys::MediaType)\r
 167                 {\r
 168                     setMediaType(READ_NODE_AS_STRING(it->second));\r
 169                 }\r
 170                 else if (key == Keys::Documentation)\r
 171                 {\r
 172                     YAML::Node docNode = it->second;\r
 173                     for ( YAML::const_iterator iit = docNode.begin(); iit != docNode.end(); ++iit )\r
 174                     {\r
 175                         std::string title ;\r
 176                         std::string content ;\r
 177 \r
 178                         for ( YAML::const_iterator tt = (*iit).begin(); tt != (*iit).end(); ++tt )\r
 179                         {\r
 180                             std::string key = READ_NODE_AS_STRING(tt->first);\r
 181 \r
 182                             if (key == Keys::Title)\r
 183                                 title = READ_NODE_AS_STRING(tt->second);\r
 184                             else if (key == Keys::Content)\r
 185                                 content = READ_NODE_AS_STRING(tt->second);\r
 186 \r
 187                         }\r
 188                         setDocumentationItem(*(new DocumentationItem(title, content)));\r
 189                     }\r
 190                 }\r
 191                 else if (key == Keys::Schemas)\r
 192                 {\r
 193                     YAML::Node schemaNode = it->second;\r
 194                     for ( YAML::const_iterator iit = schemaNode.begin(); iit != schemaNode.end(); ++iit )\r
 195                     {\r
 196                         for ( YAML::const_iterator tt = (*iit).begin(); tt != (*iit).end(); ++tt )\r
 197                         {\r
 198                             std::string key = READ_NODE_AS_STRING(tt->first);\r
 199                             std::pair<std::string, Schema> schema;\r
 200 \r
 201                             IncludeResolver::FileType fileType = m_includeResolver->getFileType(tt->second);\r
 202                             if ((fileType == IncludeResolver::FileType::JSON) || (fileType == IncludeResolver::FileType::FILE))\r
 203                             {\r
 204                                 Schema *schemaPtr = new Schema(m_includeResolver->readFromFile(tt->second));\r
 205                                 schema = std::make_pair(key, *schemaPtr);\r
 206                             }\r
 207                             else\r
 208                             {\r
 209                                 std::string value = READ_NODE_AS_STRING(tt->second);\r
 210                                 schema = std::make_pair(key, *(new Schema(value)));\r
 211                             }\r
 212                             setSchema(schema);\r
 213                         }\r
 214                     }\r
 215                 }\r
 216 \r
 217                 else if (key.compare(0, Keys::Resource.length(), Keys::Resource)  == 0)\r
 218                 {\r
 219                     RamlResource *resource = new RamlResource(key, it->second, m_includeResolver, getBaseUri());\r
 220                     setResource(key, *resource);\r
 221                 }\r
 222                 else if (key == Keys::Traits)\r
 223                 {\r
 224                     YAML::Node traitNode = it->second;\r
 225                     for ( YAML::const_iterator tt = traitNode.begin(); tt != traitNode.end(); ++tt )\r
 226                     {\r
 227                         for (auto elem : *tt)\r
 228                         {\r
 229                             std::string trait = READ_NODE_AS_STRING(elem.first);\r
 230                             Action *action = new Action(ActionType::NONE, elem.second , m_includeResolver);\r
 231 \r
 232                             std::pair<std::string, Action> resourceTrait;\r
 233                             resourceTrait = std::make_pair(trait, *action);\r
 234 \r
 235                             setTrait(resourceTrait);\r
 236                         }\r
 237                     }\r
 238                 }\r
 239                 else if (key == Keys::ResourceTypes)\r
 240                 {\r
 241                     YAML::Node typeNode = it->second;\r
 242                     for ( YAML::const_iterator tt = typeNode.begin(); tt != typeNode.end(); ++tt )\r
 243                     {\r
 244                         for (auto elem : *tt)\r
 245                         {\r
 246                             std::string type = READ_NODE_AS_STRING(elem.first);\r
 247                             RamlResource *resource = new RamlResource(type, elem.second, m_includeResolver, getBaseUri());\r
 248 \r
 249                             std::pair<std::string, RamlResource> resourceType;\r
 250                             resourceType = std::make_pair(type, *resource);\r
 251 \r
 252                             setResourceType(resourceType);\r
 253 \r
 254                         }\r
 255 \r
 256                     }\r
 257                 }\r
 258             }\r
 259         }\r
 260 \r
 261     }\r
 262 \r
 263 }\r