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
26 std::string Raml::getTitle() const
\r
30 void Raml::setTitle(const std::string &title)
\r
35 std::string Raml::getVersion() const
\r
39 void Raml::setVersion(const std::string &version)
\r
41 m_version = version;
\r
44 std::string Raml::getBaseUri() const
\r
48 void Raml::setBaseUri(const std::string &baseUri)
\r
50 m_baseUri = baseUri;
\r
53 std::list<std::string> Raml::getProtocols() const
\r
57 void Raml::setProtocol(const std::string &protocol)
\r
59 m_protocols.push_back(protocol);
\r
61 std::map<std::string, UriParameter> Raml::getBaseUriParameters() const
\r
63 return m_baseUriParameters;
\r
65 void Raml::setBaseUriParameter(const std::string ¶mName, const UriParameter &uriParameter)
\r
67 m_baseUriParameters[paramName] = uriParameter;
\r
70 std::string Raml::getMediaType() const
\r
74 void Raml::setMediaType(const std::string &mediaType)
\r
76 m_mediaType = mediaType;
\r
79 std::list<std::pair<std::string, Schema> > Raml::getSchemas() const
\r
84 void Raml::setSchema(const std::pair<std::string, Schema> &schema)
\r
86 m_schemas.push_back(schema);
\r
89 std::list<std::pair<std::string, RamlResource> > Raml::getResourceTypes() const
\r
91 return m_resourceTypes;
\r
93 void Raml::setResourceType(const std::pair<std::string, RamlResource> &resourceType)
\r
95 m_resourceTypes.push_back(resourceType);
\r
98 std::list<std::pair<std::string, Action> > Raml::getTraits() const
\r
102 void Raml::setTrait(const std::pair<std::string, Action> &trait)
\r
104 m_traits.push_back(trait);
\r
106 RamlResource &Raml::getResource(std::string resourceName)
\r
108 return m_resources[resourceName];
\r
111 std::map<std::string, RamlResource> Raml::getResources() const
\r
113 return m_resources;
\r
116 void Raml::setResource(const std::string &resourceKey, const RamlResource &resource)
\r
118 m_resources[resourceKey] = resource;
\r
121 void Raml::setDocumentationItem(const DocumentationItem &documentationItem)
\r
123 m_documentation.push_back(documentationItem);
\r
126 std::list<DocumentationItem> Raml::getDocumentation() const
\r
128 return m_documentation;
\r
130 void Raml::readRamlFromYaml(const YAML::Node &yamlNode )
\r
132 if (yamlNode.Type() == YAML::NodeType::Map)
\r
134 for ( YAML::const_iterator it = yamlNode.begin(); it != yamlNode.end(); ++it )
\r
136 std::string key = READ_NODE_AS_STRING(it->first);
\r
137 if (key == Keys::Title)
\r
139 setTitle(READ_NODE_AS_STRING(it->second));
\r
141 else if (key == Keys::Version)
\r
143 setVersion(READ_NODE_AS_STRING(it->second));
\r
145 else if (key == Keys::BaseUri)
\r
147 setBaseUri(READ_NODE_AS_STRING(it->second));
\r
149 else if ((key == Keys::BaseUriParameters) || (key == Keys::UriParameters))
\r
151 YAML::Node paramNode = it->second;
\r
152 for ( YAML::const_iterator tt = paramNode.begin(); tt != paramNode.end(); ++tt )
\r
154 UriParameter *uriParameter = new UriParameter(tt->second);
\r
155 setBaseUriParameter(READ_NODE_AS_STRING(tt->first), *uriParameter);
\r
158 else if (key == Keys::Protocols)
\r
160 YAML::Node protocolNode = it->second;
\r
161 for ( YAML::const_iterator tt = protocolNode.begin(); tt != protocolNode.end(); ++tt )
\r
163 setProtocol(READ_NODE_AS_STRING(*tt));
\r
166 else if (key == Keys::MediaType)
\r
168 setMediaType(READ_NODE_AS_STRING(it->second));
\r
170 else if (key == Keys::Documentation)
\r
172 YAML::Node docNode = it->second;
\r
173 for ( YAML::const_iterator iit = docNode.begin(); iit != docNode.end(); ++iit )
\r
175 std::string title ;
\r
176 std::string content ;
\r
178 for ( YAML::const_iterator tt = (*iit).begin(); tt != (*iit).end(); ++tt )
\r
180 std::string key = READ_NODE_AS_STRING(tt->first);
\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
188 setDocumentationItem(*(new DocumentationItem(title, content)));
\r
191 else if (key == Keys::Schemas)
\r
193 YAML::Node schemaNode = it->second;
\r
194 for ( YAML::const_iterator iit = schemaNode.begin(); iit != schemaNode.end(); ++iit )
\r
196 for ( YAML::const_iterator tt = (*iit).begin(); tt != (*iit).end(); ++tt )
\r
198 std::string key = READ_NODE_AS_STRING(tt->first);
\r
199 std::pair<std::string, Schema> schema;
\r
201 IncludeResolver::FileType fileType = m_includeResolver->getFileType(tt->second);
\r
202 if ((fileType == IncludeResolver::FileType::JSON) || (fileType == IncludeResolver::FileType::FILE))
\r
204 Schema *schemaPtr = new Schema(m_includeResolver->readFromFile(tt->second));
\r
205 schema = std::make_pair(key, *schemaPtr);
\r
209 std::string value = READ_NODE_AS_STRING(tt->second);
\r
210 schema = std::make_pair(key, *(new Schema(value)));
\r
217 else if (key.compare(0, Keys::Resource.length(), Keys::Resource) == 0)
\r
219 RamlResource *resource = new RamlResource(key, it->second, m_includeResolver, getBaseUri());
\r
220 setResource(key, *resource);
\r
222 else if (key == Keys::Traits)
\r
224 YAML::Node traitNode = it->second;
\r
225 for ( YAML::const_iterator tt = traitNode.begin(); tt != traitNode.end(); ++tt )
\r
227 for (auto elem : *tt)
\r
229 std::string trait = READ_NODE_AS_STRING(elem.first);
\r
230 Action *action = new Action(ActionType::NONE, elem.second , m_includeResolver);
\r
232 std::pair<std::string, Action> resourceTrait;
\r
233 resourceTrait = std::make_pair(trait, *action);
\r
235 setTrait(resourceTrait);
\r
239 else if (key == Keys::ResourceTypes)
\r
241 YAML::Node typeNode = it->second;
\r
242 for ( YAML::const_iterator tt = typeNode.begin(); tt != typeNode.end(); ++tt )
\r
244 for (auto elem : *tt)
\r
246 std::string type = READ_NODE_AS_STRING(elem.first);
\r
247 RamlResource *resource = new RamlResource(type, elem.second, m_includeResolver, getBaseUri());
\r
249 std::pair<std::string, RamlResource> resourceType;
\r
250 resourceType = std::make_pair(type, *resource);
\r
252 setResourceType(resourceType);
\r