| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "uri_info.h" | |
| namespace webdriver { | |
| UriInfo::UriInfo(const std::string& uri, | |
| const std::string& verb, | |
| const std::string& command_name) { | |
| ParseUri(uri, &this->fragments_, &this->parameter_indexes_); | |
| this->AddHttpVerb(verb, command_name); | |
| } | |
| void UriInfo::ParseUri(const std::string& uri, | |
| std::vector<std::string>* fragments, | |
| std::vector<size_t>* parameter_indexes) { | |
| size_t current_position = 0; | |
| size_t token_end_position = 0; | |
| size_t current_token_index = 0; | |
| do { | |
| token_end_position = uri.find("/", current_position); | |
| std::string token = uri.substr(current_position, | |
| token_end_position - current_position); | |
| if (parameter_indexes != NULL && token.find(":") == 0) { | |
| parameter_indexes->push_back(current_token_index); | |
| } | |
| fragments->push_back(token); | |
| ++current_token_index; | |
| current_position = token_end_position + 1; | |
| } while (token_end_position != std::string::npos); | |
| } | |
| bool UriInfo::IsUriMatch(const std::vector<std::string>& uri_fragments, | |
| std::vector<std::string>* uri_param_names, | |
| std::vector<std::string>* uri_param_values) { | |
| if (uri_fragments.size() != this->fragments_.size()) { | |
| return false; | |
| } | |
| // Loop through the fragments of the URI, and if any of them don't match, | |
| // then the passed in URI isn't a match. However, if the current fragment | |
| // is a template parameter (e.g., ":sessionid"), ignore the fact that the | |
| // values of the fragment don't match, and move to the next parameter index. | |
| size_t next_parameter_index = 0; | |
| for (size_t index = 0; index < this->fragments_.size(); ++index) { | |
| if (uri_fragments[index] != this->fragments_[index]) { | |
| if (this->fragments_[index].find(":") != 0) { | |
| return false; | |
| } | |
| if (next_parameter_index < this->parameter_indexes_.size() && | |
| this->parameter_indexes_[next_parameter_index] != index) { | |
| return false; | |
| } else { | |
| if (!this->IsValidParameterValue( | |
| this->fragments_[this->parameter_indexes_[next_parameter_index]], | |
| uri_fragments[this->parameter_indexes_[next_parameter_index]])) { | |
| return false; | |
| } | |
| ++next_parameter_index; | |
| } | |
| } | |
| } | |
| // At this point, we know the URI is a match. Now we just need to copy the | |
| // parameter names and values back to the caller. Note that the parameter | |
| // name has a colon in front of it which must be stripped. | |
| for (size_t index = 0; index < this->parameter_indexes_.size(); ++index) { | |
| std::string param_name = this->fragments_[this->parameter_indexes_[index]]; | |
| uri_param_names->push_back(param_name.substr(1)); | |
| uri_param_values->push_back(uri_fragments[this->parameter_indexes_[index]]); | |
| } | |
| return true; | |
| } | |
| bool UriInfo::HasHttpVerb(const std::string& http_verb, | |
| std::string* command_name) { | |
| HttpVerbMap::const_iterator verb_iterator = this->verb_map_.find(http_verb); | |
| if (verb_iterator != this->verb_map_.end()) { | |
| *command_name = verb_iterator->second; | |
| return true; | |
| } | |
| return false; | |
| } | |
| void UriInfo::AddHttpVerb(const std::string& http_verb, | |
| const std::string& command_name) { | |
| this->verb_map_[http_verb] = command_name; | |
| } | |
| bool UriInfo::IsValidParameterValue(const std::string& param_name, | |
| const std::string& param_value) { | |
| // TODO(JimEvans): Create an extensible mechanism for this. | |
| if (param_name == ":id" && param_value == "active") { | |
| return false; | |
| } | |
| return true; | |
| } | |
| std::string UriInfo::GetSupportedVerbs(void) { | |
| std::string supported_verbs = ""; | |
| HttpVerbMap::const_iterator verb_iterator = this->verb_map_.begin(); | |
| for (; verb_iterator != this->verb_map_.end(); ++verb_iterator) { | |
| if (supported_verbs.size() != 0) { | |
| supported_verbs.append(","); | |
| } | |
| supported_verbs.append(verb_iterator->first); | |
| } | |
| return supported_verbs; | |
| } | |
| } // namespace WebDriver |