Line data Source code
1 : /*
2 : *
3 : * Copyright 2015, Google Inc.
4 : * All rights reserved.
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions are
8 : * met:
9 : *
10 : * * Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : * * Redistributions in binary form must reproduce the above
13 : * copyright notice, this list of conditions and the following disclaimer
14 : * in the documentation and/or other materials provided with the
15 : * distribution.
16 : * * Neither the name of Google Inc. nor the names of its
17 : * contributors may be used to endorse or promote products derived from
18 : * this software without specific prior written permission.
19 : *
20 : * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 : * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 : * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 : * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 : * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 : * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 : * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 : *
32 : */
33 :
34 : #ifndef GRPC_INTERNAL_COMPILER_GENERATOR_HELPERS_H
35 : #define GRPC_INTERNAL_COMPILER_GENERATOR_HELPERS_H
36 :
37 : #include <map>
38 :
39 : #include "src/compiler/config.h"
40 :
41 : namespace grpc_generator {
42 :
43 48 : inline bool StripSuffix(grpc::string *filename, const grpc::string &suffix) {
44 48 : if (filename->length() >= suffix.length()) {
45 48 : size_t suffix_pos = filename->length() - suffix.length();
46 48 : if (filename->compare(suffix_pos, grpc::string::npos, suffix) == 0) {
47 24 : filename->resize(filename->size() - suffix.size());
48 24 : return true;
49 : }
50 : }
51 :
52 24 : return false;
53 : }
54 :
55 24 : inline grpc::string StripProto(grpc::string filename) {
56 24 : if (!StripSuffix(&filename, ".protodevel")) {
57 24 : StripSuffix(&filename, ".proto");
58 : }
59 24 : return filename;
60 : }
61 :
62 840 : inline grpc::string StringReplace(grpc::string str, const grpc::string &from,
63 : const grpc::string &to, bool replace_all) {
64 840 : size_t pos = 0;
65 :
66 1120 : do {
67 1960 : pos = str.find(from, pos);
68 1960 : if (pos == grpc::string::npos) {
69 840 : break;
70 : }
71 1120 : str.replace(pos, from.length(), to);
72 1120 : pos += to.length();
73 : } while(replace_all);
74 :
75 840 : return str;
76 : }
77 :
78 840 : inline grpc::string StringReplace(grpc::string str, const grpc::string &from,
79 : const grpc::string &to) {
80 840 : return StringReplace(str, from, to, true);
81 : }
82 :
83 32 : inline std::vector<grpc::string> tokenize(const grpc::string &input,
84 : const grpc::string &delimiters) {
85 32 : std::vector<grpc::string> tokens;
86 32 : size_t pos, last_pos = 0;
87 :
88 : for (;;) {
89 92 : bool done = false;
90 92 : pos = input.find_first_of(delimiters, last_pos);
91 92 : if (pos == grpc::string::npos) {
92 32 : done = true;
93 32 : pos = input.length();
94 : }
95 :
96 92 : tokens.push_back(input.substr(last_pos, pos - last_pos));
97 124 : if (done) return tokens;
98 :
99 60 : last_pos = pos + 1;
100 60 : }
101 : }
102 :
103 : inline grpc::string CapitalizeFirstLetter(grpc::string s) {
104 : if (s.empty()) {
105 : return s;
106 : }
107 : s[0] = ::toupper(s[0]);
108 : return s;
109 : }
110 :
111 : inline grpc::string LowercaseFirstLetter(grpc::string s) {
112 : if (s.empty()) {
113 : return s;
114 : }
115 : s[0] = ::tolower(s[0]);
116 : return s;
117 : }
118 :
119 : inline grpc::string LowerUnderscoreToUpperCamel(grpc::string str) {
120 : std::vector<grpc::string> tokens = tokenize(str, "_");
121 : grpc::string result = "";
122 : for (unsigned int i = 0; i < tokens.size(); i++) {
123 : result += CapitalizeFirstLetter(tokens[i]);
124 : }
125 : return result;
126 : }
127 :
128 : inline grpc::string FileNameInUpperCamel(const grpc::protobuf::FileDescriptor *file,
129 : bool include_package_path) {
130 : std::vector<grpc::string> tokens = tokenize(StripProto(file->name()), "/");
131 : grpc::string result = "";
132 : if (include_package_path) {
133 : for (unsigned int i = 0; i < tokens.size() - 1; i++) {
134 : result += tokens[i] + "/";
135 : }
136 : }
137 : result += LowerUnderscoreToUpperCamel(tokens.back());
138 : return result;
139 : }
140 :
141 : inline grpc::string FileNameInUpperCamel(const grpc::protobuf::FileDescriptor *file) {
142 : return FileNameInUpperCamel(file, true);
143 : }
144 :
145 : enum MethodType {
146 : METHODTYPE_NO_STREAMING,
147 : METHODTYPE_CLIENT_STREAMING,
148 : METHODTYPE_SERVER_STREAMING,
149 : METHODTYPE_BIDI_STREAMING
150 : };
151 :
152 : inline MethodType GetMethodType(const grpc::protobuf::MethodDescriptor *method) {
153 : if (method->client_streaming()) {
154 : if (method->server_streaming()) {
155 : return METHODTYPE_BIDI_STREAMING;
156 : } else {
157 : return METHODTYPE_CLIENT_STREAMING;
158 : }
159 : } else {
160 : if (method->server_streaming()) {
161 : return METHODTYPE_SERVER_STREAMING;
162 : } else {
163 : return METHODTYPE_NO_STREAMING;
164 : }
165 : }
166 : }
167 :
168 : } // namespace grpc_generator
169 :
170 : #endif // GRPC_INTERNAL_COMPILER_GENERATOR_HELPERS_H
|
