cpp_helpers.h revision fbaaef999ba563838ebd00874ed8a1c01fbf286d
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// Based on original Protocol Buffers design by 33// Sanjay Ghemawat, Jeff Dean, and others. 34 35#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__ 36#define GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__ 37 38#include <string> 39#include <google/protobuf/descriptor.h> 40#include <google/protobuf/descriptor.pb.h> 41 42namespace google { 43namespace protobuf { 44namespace compiler { 45namespace cpp { 46 47// Commonly-used separator comments. Thick is a line of '=', thin is a line 48// of '-'. 49extern const char kThickSeparator[]; 50extern const char kThinSeparator[]; 51 52// Returns the non-nested type name for the given type. If "qualified" is 53// true, prefix the type with the full namespace. For example, if you had: 54// package foo.bar; 55// message Baz { message Qux {} } 56// Then the qualified ClassName for Qux would be: 57// ::foo::bar::Baz_Qux 58// While the non-qualified version would be: 59// Baz_Qux 60string ClassName(const Descriptor* descriptor, bool qualified); 61string ClassName(const EnumDescriptor* enum_descriptor, bool qualified); 62 63// Get the (unqualified) name that should be used for this field in C++ code. 64// The name is coerced to lower-case to emulate proto1 behavior. People 65// should be using lowercase-with-underscores style for proto field names 66// anyway, so normally this just returns field->name(). 67string FieldName(const FieldDescriptor* field); 68 69// Get the unqualified name that should be used for a field's field 70// number constant. 71string FieldConstantName(const FieldDescriptor *field); 72 73// Returns the scope where the field was defined (for extensions, this is 74// different from the message type to which the field applies). 75inline const Descriptor* FieldScope(const FieldDescriptor* field) { 76 return field->is_extension() ? 77 field->extension_scope() : field->containing_type(); 78} 79 80// Strips ".proto" or ".protodevel" from the end of a filename. 81string StripProto(const string& filename); 82 83// Get the C++ type name for a primitive type (e.g. "double", "::google::protobuf::int32", etc.). 84// Note: non-built-in type names will be qualified, meaning they will start 85// with a ::. If you are using the type as a template parameter, you will 86// need to insure there is a space between the < and the ::, because the 87// ridiculous C++ standard defines "<:" to be a synonym for "[". 88const char* PrimitiveTypeName(FieldDescriptor::CppType type); 89 90// Get the declared type name in CamelCase format, as is used e.g. for the 91// methods of WireFormat. For example, TYPE_INT32 becomes "Int32". 92const char* DeclaredTypeMethodName(FieldDescriptor::Type type); 93 94// Get code that evaluates to the field's default value. 95string DefaultValue(const FieldDescriptor* field); 96 97// Convert a file name into a valid identifier. 98string FilenameIdentifier(const string& filename); 99 100// Return the name of the AddDescriptors() function for a given file. 101string GlobalAddDescriptorsName(const string& filename); 102 103// Return the name of the AssignDescriptors() function for a given file. 104string GlobalAssignDescriptorsName(const string& filename); 105 106// Return the name of the ShutdownFile() function for a given file. 107string GlobalShutdownFileName(const string& filename); 108 109// Do message classes in this file keep track of unknown fields? 110inline const bool HasUnknownFields(const FileDescriptor *file) { 111 return file->options().optimize_for() != FileOptions::LITE_RUNTIME; 112} 113 114// Does this file have generated parsing, serialization, and other 115// standard methods for which reflection-based fallback implementations exist? 116inline const bool HasGeneratedMethods(const FileDescriptor *file) { 117 return file->options().optimize_for() != FileOptions::CODE_SIZE; 118} 119 120// Do message classes in this file have descriptor and refelction methods? 121inline const bool HasDescriptorMethods(const FileDescriptor *file) { 122 return file->options().optimize_for() != FileOptions::LITE_RUNTIME; 123} 124 125// Should string fields in this file verify that their contents are UTF-8? 126inline const bool HasUtf8Verification(const FileDescriptor* file) { 127 return file->options().optimize_for() != FileOptions::LITE_RUNTIME; 128} 129 130// Should we generate a separate, super-optimized code path for serializing to 131// flat arrays? We don't do this in Lite mode because we'd rather reduce code 132// size. 133inline const bool HasFastArraySerialization(const FileDescriptor* file) { 134 return file->options().optimize_for() == FileOptions::SPEED; 135} 136 137} // namespace cpp 138} // namespace compiler 139} // namespace protobuf 140 141} // namespace google 142#endif // GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__ 143