| /* |
| * |
| * Copyright 2015 gRPC authors. |
| * |
| * Licensed 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. |
| * |
| */ |
| |
| #ifndef GRPC_INTERNAL_COMPILER_RUBY_GENERATOR_STRING_INL_H |
| #define GRPC_INTERNAL_COMPILER_RUBY_GENERATOR_STRING_INL_H |
| |
| #include "src/compiler/config.h" |
| |
| #include <algorithm> |
| #include <sstream> |
| #include <vector> |
| |
| using std::getline; |
| using std::transform; |
| |
| namespace grpc_ruby_generator { |
| |
| // Split splits a string using char into elems. |
| inline std::vector<grpc::string>& Split(const grpc::string& s, char delim, |
| std::vector<grpc::string>* elems) { |
| std::stringstream ss(s); |
| grpc::string item; |
| while (getline(ss, item, delim)) { |
| elems->push_back(item); |
| } |
| return *elems; |
| } |
| |
| // Split splits a string using char, returning the result in a vector. |
| inline std::vector<grpc::string> Split(const grpc::string& s, char delim) { |
| std::vector<grpc::string> elems; |
| Split(s, delim, &elems); |
| return elems; |
| } |
| |
| // Replace replaces from with to in s. |
| inline grpc::string Replace(grpc::string s, const grpc::string& from, |
| const grpc::string& to) { |
| size_t start_pos = s.find(from); |
| if (start_pos == grpc::string::npos) { |
| return s; |
| } |
| s.replace(start_pos, from.length(), to); |
| return s; |
| } |
| |
| // ReplaceAll replaces all instances of search with replace in s. |
| inline grpc::string ReplaceAll(grpc::string s, const grpc::string& search, |
| const grpc::string& replace) { |
| size_t pos = 0; |
| while ((pos = s.find(search, pos)) != grpc::string::npos) { |
| s.replace(pos, search.length(), replace); |
| pos += replace.length(); |
| } |
| return s; |
| } |
| |
| // ReplacePrefix replaces from with to in s if search is a prefix of s. |
| inline bool ReplacePrefix(grpc::string* s, const grpc::string& from, |
| const grpc::string& to) { |
| size_t start_pos = s->find(from); |
| if (start_pos == grpc::string::npos || start_pos != 0) { |
| return false; |
| } |
| s->replace(start_pos, from.length(), to); |
| return true; |
| } |
| |
| // Modularize converts a string into a ruby module compatible name |
| inline grpc::string Modularize(grpc::string s) { |
| if (s.empty()) { |
| return s; |
| } |
| grpc::string new_string = ""; |
| bool was_last_underscore = false; |
| new_string.append(1, ::toupper(s[0])); |
| for (grpc::string::size_type i = 1; i < s.size(); ++i) { |
| if (was_last_underscore && s[i] != '_') { |
| new_string.append(1, ::toupper(s[i])); |
| } else if (s[i] != '_') { |
| new_string.append(1, s[i]); |
| } |
| was_last_underscore = s[i] == '_'; |
| } |
| return new_string; |
| } |
| |
| // RubyTypeOf updates a proto type to the required ruby equivalent. |
| inline grpc::string RubyTypeOf(const grpc::string& a_type, |
| const grpc::string& package) { |
| grpc::string res(a_type); |
| ReplacePrefix(&res, package, ""); // remove the leading package if present |
| ReplacePrefix(&res, ".", ""); // remove the leading . (no package) |
| if (res.find('.') == grpc::string::npos) { |
| return res; |
| } else { |
| std::vector<grpc::string> prefixes_and_type = Split(res, '.'); |
| res.clear(); |
| for (unsigned int i = 0; i < prefixes_and_type.size(); ++i) { |
| if (i != 0) { |
| res += "::"; // switch '.' to the ruby module delim |
| } |
| if (i < prefixes_and_type.size() - 1) { |
| res += Modularize(prefixes_and_type[i]); // capitalize pkgs |
| } else { |
| res += prefixes_and_type[i]; |
| } |
| } |
| return res; |
| } |
| } |
| |
| } // namespace grpc_ruby_generator |
| |
| #endif // GRPC_INTERNAL_COMPILER_RUBY_GENERATOR_STRING_INL_H |