LCOV - code coverage report
Current view: top level - compiler - generator_helpers.h (source / functions) Hit Total Coverage
Test: tmp.CaZ6RjdVn2 Lines: 34 34 100.0 %
Date: 2015-12-10 22:15:08 Functions: 5 5 100.0 %

          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        2040 : inline bool StripSuffix(grpc::string *filename, const grpc::string &suffix) {
      44        2040 :   if (filename->length() >= suffix.length()) {
      45        2040 :     size_t suffix_pos = filename->length() - suffix.length();
      46        2040 :     if (filename->compare(suffix_pos, grpc::string::npos, suffix) == 0) {
      47        1020 :       filename->resize(filename->size() - suffix.size());
      48        1020 :       return true;
      49             :     }
      50             :   }
      51             : 
      52        1020 :   return false;
      53             : }
      54             : 
      55        1020 : inline grpc::string StripProto(grpc::string filename) {
      56        1020 :   if (!StripSuffix(&filename, ".protodevel")) {
      57        1020 :     StripSuffix(&filename, ".proto");
      58             :   }
      59        1020 :   return filename;
      60             : }
      61             : 
      62        2888 : inline grpc::string StringReplace(grpc::string str, const grpc::string &from,
      63             :                                   const grpc::string &to, bool replace_all) {
      64        2888 :   size_t pos = 0;
      65             : 
      66        1488 :   do {
      67        4376 :     pos = str.find(from, pos);
      68        4376 :     if (pos == grpc::string::npos) {
      69        2888 :       break;
      70             :     }
      71        1488 :     str.replace(pos, from.length(), to);
      72        1488 :     pos += to.length();
      73             :   } while(replace_all);
      74             : 
      75        2888 :   return str;
      76             : }
      77             : 
      78        2888 : inline grpc::string StringReplace(grpc::string str, const grpc::string &from,
      79             :                                   const grpc::string &to) {
      80        2888 :   return StringReplace(str, from, to, true);
      81             : }
      82             : 
      83          48 : inline std::vector<grpc::string> tokenize(const grpc::string &input,
      84             :                                           const grpc::string &delimiters) {
      85          48 :   std::vector<grpc::string> tokens;
      86          48 :   size_t pos, last_pos = 0;
      87             : 
      88             :   for (;;) {
      89         124 :     bool done = false;
      90         124 :     pos = input.find_first_of(delimiters, last_pos);
      91         124 :     if (pos == grpc::string::npos) {
      92          48 :       done = true;
      93          48 :       pos = input.length();
      94             :     }
      95             : 
      96         124 :     tokens.push_back(input.substr(last_pos, pos - last_pos));
      97         172 :     if (done) return tokens;
      98             : 
      99          76 :     last_pos = pos + 1;
     100          76 :   }
     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

Generated by: LCOV version 1.11