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> const &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, UriParameterPtr> const &Raml::getBaseUriParameters() const\r
  62     {\r
  63         return m_baseUriParameters;\r
  64     }\r
  65     void Raml::setBaseUriParameter(const std::string &paramName, const UriParameterPtr &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, SchemaPtr> > const &Raml::getSchemas() const\r
  80     {\r
  81         return m_schemas;\r
  82     }\r
  83 \r
  84     void Raml::setSchema(const std::string &schemaName, const SchemaPtr &schema)\r
  85     {\r
  86         m_schemas.push_back(std::make_pair(schemaName, schema));\r
  87     }\r
  88 \r
  89     std::list<std::pair<std::string, RamlResourcePtr> > const &Raml::getResourceTypes() const\r
  90     {\r
  91         return m_resourceTypes;\r
  92     }\r
  93     void Raml::setResourceType(const std::string &typeName, const RamlResourcePtr &resourceType)\r
  94     {\r
  95         m_resourceTypes.push_back(std::make_pair(typeName, resourceType));\r
  96     }\r
  97 \r
  98     std::list<std::pair<std::string, ActionPtr> > const &Raml::getTraits() const\r
  99     {\r
 100         return m_traits;\r
 101     }\r
 102     void Raml::setTrait(const std::string &traitName, const ActionPtr &trait)\r
 103     {\r
 104         m_traits.push_back(std::make_pair(traitName, trait));\r
 105     }\r
 106     RamlResourcePtr Raml::getResource(const std::string &resourceName)\r
 107     {\r
 108         return m_resources[resourceName];\r
 109     }\r
 110 \r
 111     std::map<std::string, RamlResourcePtr> const &Raml::getResources() const\r
 112     {\r
 113         return m_resources;\r
 114     }\r
 115 \r
 116     void Raml::setResource(const std::string &resourceKey, const RamlResourcePtr &resource)\r
 117     {\r
 118         m_resources[resourceKey] = resource;\r
 119     }\r
 120 \r
 121     void Raml::setDocumentationItem(const std::shared_ptr<DocumentationItem> &documentationItem)\r
 122     {\r
 123         m_documentation.push_back(documentationItem);\r
 124     }\r
 125 \r
 126     std::list<std::shared_ptr<DocumentationItem> > const &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                         setBaseUriParameter(READ_NODE_AS_STRING(tt->first), std::make_shared<UriParameter>(tt->second));\r
 155                     }\r
 156                 }\r
 157                 else if (key == Keys::Protocols)\r
 158                 {\r
 159                     YAML::Node protocolNode = it->second;\r
 160                     for ( YAML::const_iterator tt = protocolNode.begin(); tt != protocolNode.end(); ++tt )\r
 161                     {\r
 162                         setProtocol(READ_NODE_AS_STRING(*tt));\r
 163                     }\r
 164                 }\r
 165                 else if (key == Keys::MediaType)\r
 166                 {\r
 167                     setMediaType(READ_NODE_AS_STRING(it->second));\r
 168                 }\r
 169                 else if (key == Keys::Documentation)\r
 170                 {\r
 171                     YAML::Node docNode = it->second;\r
 172                     for ( YAML::const_iterator iit = docNode.begin(); iit != docNode.end(); ++iit )\r
 173                     {\r
 174                         std::string title ;\r
 175                         std::string content ;\r
 176 \r
 177                         for ( YAML::const_iterator tt = (*iit).begin(); tt != (*iit).end(); ++tt )\r
 178                         {\r
 179                             std::string key = READ_NODE_AS_STRING(tt->first);\r
 180 \r
 181                             if (key == Keys::Title)\r
 182                                 title = READ_NODE_AS_STRING(tt->second);\r
 183                             else if (key == Keys::Content)\r
 184                                 content = READ_NODE_AS_STRING(tt->second);\r
 185 \r
 186                         }\r
 187                         setDocumentationItem(std::make_shared<DocumentationItem>(title, content));\r
 188                     }\r
 189                 }\r
 190                 else if (key == Keys::Schemas)\r
 191                 {\r
 192                     YAML::Node schemaNode = it->second;\r
 193                     for ( YAML::const_iterator iit = schemaNode.begin(); iit != schemaNode.end(); ++iit )\r
 194                     {\r
 195                         for ( YAML::const_iterator tt = (*iit).begin(); tt != (*iit).end(); ++tt )\r
 196                         {\r
 197                             std::string key = READ_NODE_AS_STRING(tt->first);\r
 198                             std::pair<std::string, Schema> schema;\r
 199 \r
 200                             IncludeResolver::FileType fileType = m_includeResolver->getFileType(tt->second);\r
 201                             if ((fileType == IncludeResolver::FileType::JSON) || (fileType == IncludeResolver::FileType::FILE))\r
 202                             {\r
 203                                 setSchema(key, std::make_shared<Schema>(m_includeResolver->readFromFile(tt->second),\r
 204                                                                         m_includeResolver));\r
 205                             }\r
 206                             else\r
 207                             {\r
 208                                 setSchema(key, std::make_shared<Schema>(READ_NODE_AS_STRING(tt->second), m_includeResolver));\r
 209                             }\r
 210                         }\r
 211                     }\r
 212                 }\r
 213 \r
 214                 else if (key.compare(0, Keys::Resource.length(), Keys::Resource)  == 0)\r
 215                 {\r
 216                     setResource(key, std::make_shared<RamlResource>(key, it->second, m_includeResolver, getBaseUri()));\r
 217                 }\r
 218                 else if (key == Keys::Traits)\r
 219                 {\r
 220                     YAML::Node traitNode = it->second;\r
 221                     for ( YAML::const_iterator tt = traitNode.begin(); tt != traitNode.end(); ++tt )\r
 222                     {\r
 223                         for (auto elem : *tt)\r
 224                         {\r
 225                             std::string trait = READ_NODE_AS_STRING(elem.first);\r
 226                             setTrait(trait, std::make_shared<Action>(ActionType::NONE, elem.second , m_includeResolver));\r
 227                         }\r
 228                     }\r
 229                 }\r
 230                 else if (key == Keys::ResourceTypes)\r
 231                 {\r
 232                     YAML::Node typeNode = it->second;\r
 233                     for ( YAML::const_iterator tt = typeNode.begin(); tt != typeNode.end(); ++tt )\r
 234                     {\r
 235                         for (auto elem : *tt)\r
 236                         {\r
 237                             std::string type = READ_NODE_AS_STRING(elem.first);\r
 238                             setResourceType(type, std::make_shared<RamlResource>(type, elem.second, m_includeResolver,\r
 239                                             getBaseUri()));\r
 240 \r
 241                         }\r
 242 \r
 243                     }\r
 244                 }\r
 245             }\r
 246         }\r
 247 \r
 248     }\r
 249 \r
 250 }\r