PageRenderTime 15ms CodeModel.GetById 1ms app.highlight 11ms RepoModel.GetById 1ms app.codeStats 0ms

/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/stubs/substitute.h

http://github.com/tomahawk-player/tomahawk
C++ Header | 170 lines | 77 code | 16 blank | 77 comment | 0 complexity | 31313a006d9f1e6af6cad4dc4e48d412 MD5 | raw file
  1// Protocol Buffers - Google's data interchange format
  2// Copyright 2008 Google Inc.  All rights reserved.
  3// http://code.google.com/p/protobuf/
  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
 41namespace google {
 42namespace protobuf {
 43namespace strings {
 44
 45// ----------------------------------------------------------------------
 46// strings::Substitute()
 47// strings::SubstituteAndAppend()
 48//   Kind of like StringPrintf, but different.
 49//
 50//   Example:
 51//     string GetMessage(string first_name, string last_name, int age) {
 52//       return strings::Substitute("My name is $0 $1 and I am $2 years old.",
 53//                                  first_name, last_name, age);
 54//     }
 55//
 56//   Differences from StringPrintf:
 57//   * The format string does not identify the types of arguments.
 58//     Instead, the magic of C++ deals with this for us.  See below
 59//     for a list of accepted types.
 60//   * Substitutions in the format string are identified by a '$'
 61//     followed by a digit.  So, you can use arguments out-of-order and
 62//     use the same argument multiple times.
 63//   * It's much faster than StringPrintf.
 64//
 65//   Supported types:
 66//   * Strings (const char*, const string&)
 67//     * Note that this means you do not have to add .c_str() to all of
 68//       your strings.  In fact, you shouldn't; it will be slower.
 69//   * int32, int64, uint32, uint64:  Formatted using SimpleItoa().
 70//   * float, double:  Formatted using SimpleFtoa() and SimpleDtoa().
 71//   * bool:  Printed as "true" or "false".
 72//
 73//   SubstituteAndAppend() is like Substitute() but appends the result to
 74//   *output.  Example:
 75//
 76//     string str;
 77//     strings::SubstituteAndAppend(&str,
 78//                                  "My name is $0 $1 and I am $2 years old.",
 79//                                  first_name, last_name, age);
 80//
 81//   Substitute() is significantly faster than StringPrintf().  For very
 82//   large strings, it may be orders of magnitude faster.
 83// ----------------------------------------------------------------------
 84
 85namespace internal {  // Implementation details.
 86
 87class SubstituteArg {
 88 public:
 89  inline SubstituteArg(const char* value)
 90    : text_(value), size_(strlen(text_)) {}
 91  inline SubstituteArg(const string& value)
 92    : text_(value.data()), size_(value.size()) {}
 93
 94  // Indicates that no argument was given.
 95  inline explicit SubstituteArg()
 96    : text_(NULL), size_(-1) {}
 97
 98  // Primitives
 99  // We don't overload for signed and unsigned char because if people are
100  // explicitly declaring their chars as signed or unsigned then they are
101  // probably actually using them as 8-bit integers and would probably
102  // prefer an integer representation.  But, we don't really know.  So, we
103  // make the caller decide what to do.
104  inline SubstituteArg(char value)
105    : text_(scratch_), size_(1) { scratch_[0] = value; }
106  inline SubstituteArg(short value)
107    : text_(FastInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {}
108  inline SubstituteArg(unsigned short value)
109    : text_(FastUInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {}
110  inline SubstituteArg(int value)
111    : text_(FastInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {}
112  inline SubstituteArg(unsigned int value)
113    : text_(FastUInt32ToBuffer(value, scratch_)), size_(strlen(text_)) {}
114  inline SubstituteArg(long value)
115    : text_(FastLongToBuffer(value, scratch_)), size_(strlen(text_)) {}
116  inline SubstituteArg(unsigned long value)
117    : text_(FastULongToBuffer(value, scratch_)), size_(strlen(text_)) {}
118  inline SubstituteArg(long long value)
119    : text_(FastInt64ToBuffer(value, scratch_)), size_(strlen(text_)) {}
120  inline SubstituteArg(unsigned long long value)
121    : text_(FastUInt64ToBuffer(value, scratch_)), size_(strlen(text_)) {}
122  inline SubstituteArg(float value)
123    : text_(FloatToBuffer(value, scratch_)), size_(strlen(text_)) {}
124  inline SubstituteArg(double value)
125    : text_(DoubleToBuffer(value, scratch_)), size_(strlen(text_)) {}
126  inline SubstituteArg(bool value)
127    : text_(value ? "true" : "false"), size_(strlen(text_)) {}
128
129  inline const char* data() const { return text_; }
130  inline int size() const { return size_; }
131
132 private:
133  const char* text_;
134  int size_;
135  char scratch_[kFastToBufferSize];
136};
137
138}  // namespace internal
139
140LIBPROTOBUF_EXPORT string Substitute(
141  const char* format,
142  const internal::SubstituteArg& arg0 = internal::SubstituteArg(),
143  const internal::SubstituteArg& arg1 = internal::SubstituteArg(),
144  const internal::SubstituteArg& arg2 = internal::SubstituteArg(),
145  const internal::SubstituteArg& arg3 = internal::SubstituteArg(),
146  const internal::SubstituteArg& arg4 = internal::SubstituteArg(),
147  const internal::SubstituteArg& arg5 = internal::SubstituteArg(),
148  const internal::SubstituteArg& arg6 = internal::SubstituteArg(),
149  const internal::SubstituteArg& arg7 = internal::SubstituteArg(),
150  const internal::SubstituteArg& arg8 = internal::SubstituteArg(),
151  const internal::SubstituteArg& arg9 = internal::SubstituteArg());
152
153LIBPROTOBUF_EXPORT void SubstituteAndAppend(
154  string* output, const char* format,
155  const internal::SubstituteArg& arg0 = internal::SubstituteArg(),
156  const internal::SubstituteArg& arg1 = internal::SubstituteArg(),
157  const internal::SubstituteArg& arg2 = internal::SubstituteArg(),
158  const internal::SubstituteArg& arg3 = internal::SubstituteArg(),
159  const internal::SubstituteArg& arg4 = internal::SubstituteArg(),
160  const internal::SubstituteArg& arg5 = internal::SubstituteArg(),
161  const internal::SubstituteArg& arg6 = internal::SubstituteArg(),
162  const internal::SubstituteArg& arg7 = internal::SubstituteArg(),
163  const internal::SubstituteArg& arg8 = internal::SubstituteArg(),
164  const internal::SubstituteArg& arg9 = internal::SubstituteArg());
165
166}  // namespace strings
167}  // namespace protobuf
168}  // namespace google
169
170#endif // GOOGLE_PROTOBUF_STUBS_SUBSTITUTE_H_