1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2008 Google Inc. All rights reserved. 3 // https://developers.google.com/protocol-buffers/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 // Author: kenton@google.com (Kenton Varda) 32 // from google3/strings/substitute.h 33 34 #include <string> 35 #include <google/protobuf/stubs/common.h> 36 #include <google/protobuf/stubs/strutil.h> 37 38 #ifndef GOOGLE_PROTOBUF_STUBS_SUBSTITUTE_H_ 39 #define GOOGLE_PROTOBUF_STUBS_SUBSTITUTE_H_ 40 41 #include <google/protobuf/port_def.inc> 42 43 namespace google { 44 namespace protobuf { 45 namespace strings { 46 47 // ---------------------------------------------------------------------- 48 // strings::Substitute() 49 // strings::SubstituteAndAppend() 50 // Kind of like StringPrintf, but different. 51 // 52 // Example: 53 // string GetMessage(string first_name, string last_name, int age) { 54 // return strings::Substitute("My name is $0 $1 and I am $2 years old.", 55 // first_name, last_name, age); 56 // } 57 // 58 // Differences from StringPrintf: 59 // * The format string does not identify the types of arguments. 60 // Instead, the magic of C++ deals with this for us. See below 61 // for a list of accepted types. 62 // * Substitutions in the format string are identified by a '$' 63 // followed by a digit. So, you can use arguments out-of-order and 64 // use the same argument multiple times. 65 // * It's much faster than StringPrintf. 66 // 67 // Supported types: 68 // * Strings (const char*, const string&) 69 // * Note that this means you do not have to add .c_str() to all of 70 // your strings. In fact, you shouldn't; it will be slower. 71 // * int32, int64, uint32, uint64: Formatted using SimpleItoa(). 72 // * float, double: Formatted using SimpleFtoa() and SimpleDtoa(). 73 // * bool: Printed as "true" or "false". 74 // 75 // SubstituteAndAppend() is like Substitute() but appends the result to 76 // *output. Example: 77 // 78 // string str; 79 // strings::SubstituteAndAppend(&str, 80 // "My name is $0 $1 and I am $2 years old.", 81 // first_name, last_name, age); 82 // 83 // Substitute() is significantly faster than StringPrintf(). For very 84 // large strings, it may be orders of magnitude faster. 85 // ---------------------------------------------------------------------- 86 87 namespace internal { // Implementation details. 88 89 class SubstituteArg { 90 public: SubstituteArg(const char * value)91 inline SubstituteArg(const char* value) 92 : text_(value), size_(strlen(text_)) {} SubstituteArg(const string & value)93 inline SubstituteArg(const string& value) 94 : text_(value.data()), size_(value.size()) {} 95 96 // Indicates that no argument was given. SubstituteArg()97 inline explicit SubstituteArg() 98 : text_(nullptr), size_(-1) {} 99 100 // Primitives 101 // We don't overload for signed and unsigned char because if people are 102 // explicitly declaring their chars as signed or unsigned then they are 103 // probably actually using them as 8-bit integers and would probably 104 // prefer an integer representation. But, we don't really know. So, we 105 // make the caller decide what to do. SubstituteArg(char value)106 inline SubstituteArg(char value) 107 : text_(scratch_), size_(1) { scratch_[0] = value; } SubstituteArg(short value)108 inline SubstituteArg(short value) 109 : text_(FastInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(unsigned short value)110 inline SubstituteArg(unsigned short value) 111 : text_(FastUInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(int value)112 inline SubstituteArg(int value) 113 : text_(FastInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(unsigned int value)114 inline SubstituteArg(unsigned int value) 115 : text_(FastUInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(long value)116 inline SubstituteArg(long value) 117 : text_(FastLongToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(unsigned long value)118 inline SubstituteArg(unsigned long value) 119 : text_(FastULongToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(long long value)120 inline SubstituteArg(long long value) 121 : text_(FastInt64ToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(unsigned long long value)122 inline SubstituteArg(unsigned long long value) 123 : text_(FastUInt64ToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(float value)124 inline SubstituteArg(float value) 125 : text_(FloatToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(double value)126 inline SubstituteArg(double value) 127 : text_(DoubleToBuffer(value, scratch_)), size_(strlen(text_)) {} SubstituteArg(bool value)128 inline SubstituteArg(bool value) 129 : text_(value ? "true" : "false"), size_(strlen(text_)) {} 130 data()131 inline const char* data() const { return text_; } size()132 inline int size() const { return size_; } 133 134 private: 135 const char* text_; 136 int size_; 137 char scratch_[kFastToBufferSize]; 138 }; 139 140 } // namespace internal 141 142 PROTOBUF_EXPORT string 143 Substitute(const char* format, 144 const internal::SubstituteArg& arg0 = internal::SubstituteArg(), 145 const internal::SubstituteArg& arg1 = internal::SubstituteArg(), 146 const internal::SubstituteArg& arg2 = internal::SubstituteArg(), 147 const internal::SubstituteArg& arg3 = internal::SubstituteArg(), 148 const internal::SubstituteArg& arg4 = internal::SubstituteArg(), 149 const internal::SubstituteArg& arg5 = internal::SubstituteArg(), 150 const internal::SubstituteArg& arg6 = internal::SubstituteArg(), 151 const internal::SubstituteArg& arg7 = internal::SubstituteArg(), 152 const internal::SubstituteArg& arg8 = internal::SubstituteArg(), 153 const internal::SubstituteArg& arg9 = internal::SubstituteArg()); 154 155 PROTOBUF_EXPORT void SubstituteAndAppend( 156 string* output, const char* format, 157 const internal::SubstituteArg& arg0 = internal::SubstituteArg(), 158 const internal::SubstituteArg& arg1 = internal::SubstituteArg(), 159 const internal::SubstituteArg& arg2 = internal::SubstituteArg(), 160 const internal::SubstituteArg& arg3 = internal::SubstituteArg(), 161 const internal::SubstituteArg& arg4 = internal::SubstituteArg(), 162 const internal::SubstituteArg& arg5 = internal::SubstituteArg(), 163 const internal::SubstituteArg& arg6 = internal::SubstituteArg(), 164 const internal::SubstituteArg& arg7 = internal::SubstituteArg(), 165 const internal::SubstituteArg& arg8 = internal::SubstituteArg(), 166 const internal::SubstituteArg& arg9 = internal::SubstituteArg()); 167 168 } // namespace strings 169 } // namespace protobuf 170 } // namespace google 171 172 #include <google/protobuf/port_undef.inc> 173 174 #endif // GOOGLE_PROTOBUF_STUBS_SUBSTITUTE_H_ 175