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 63string SuperClassName(const Descriptor* descriptor); 64 65// Get the (unqualified) name that should be used for this field in C++ code. 66// The name is coerced to lower-case to emulate proto1 behavior. People 67// should be using lowercase-with-underscores style for proto field names 68// anyway, so normally this just returns field->name(). 69string FieldName(const FieldDescriptor* field); 70 71// Get the unqualified name that should be used for a field's field 72// number constant. 73string FieldConstantName(const FieldDescriptor *field); 74 75// Returns the scope where the field was defined (for extensions, this is 76// different from the message type to which the field applies). 77inline const Descriptor* FieldScope(const FieldDescriptor* field) { 78 return field->is_extension() ? 79 field->extension_scope() : field->containing_type(); 80} 81 82// Returns the fully-qualified type name field->message_type(). Usually this 83// is just ClassName(field->message_type(), true); 84string FieldMessageTypeName(const FieldDescriptor* field); 85 86// Strips ".proto" or ".protodevel" from the end of a filename. 87string StripProto(const string& filename); 88 89// Get the C++ type name for a primitive type (e.g. "double", "::google::protobuf::int32", etc.). 90// Note: non-built-in type names will be qualified, meaning they will start 91// with a ::. If you are using the type as a template parameter, you will 92// need to insure there is a space between the < and the ::, because the 93// ridiculous C++ standard defines "<:" to be a synonym for "[". 94const char* PrimitiveTypeName(FieldDescriptor::CppType type); 95 96// Get the declared type name in CamelCase format, as is used e.g. for the 97// methods of WireFormat. For example, TYPE_INT32 becomes "Int32". 98const char* DeclaredTypeMethodName(FieldDescriptor::Type type); 99 100// Get code that evaluates to the field's default value. 101string DefaultValue(const FieldDescriptor* field); 102 103// Convert a file name into a valid identifier. 104string FilenameIdentifier(const string& filename); 105 106// Return the name of the AddDescriptors() function for a given file. 107string GlobalAddDescriptorsName(const string& filename); 108 109// Return the name of the AssignDescriptors() function for a given file. 110string GlobalAssignDescriptorsName(const string& filename); 111 112// Return the name of the ShutdownFile() function for a given file. 113string GlobalShutdownFileName(const string& filename); 114 115// Do message classes in this file keep track of unknown fields? 116inline bool HasUnknownFields(const FileDescriptor *file) { 117 return file->options().optimize_for() != FileOptions::LITE_RUNTIME; 118} 119 120// Does this file have generated parsing, serialization, and other 121// standard methods for which reflection-based fallback implementations exist? 122inline bool HasGeneratedMethods(const FileDescriptor *file) { 123 return file->options().optimize_for() != FileOptions::CODE_SIZE; 124} 125 126// Do message classes in this file have descriptor and refelction methods? 127inline bool HasDescriptorMethods(const FileDescriptor *file) { 128 return file->options().optimize_for() != FileOptions::LITE_RUNTIME; 129} 130 131// Should we generate generic services for this file? 132inline bool HasGenericServices(const FileDescriptor *file) { 133 return file->service_count() > 0 && 134 file->options().optimize_for() != FileOptions::LITE_RUNTIME && 135 file->options().cc_generic_services(); 136} 137 138// Should string fields in this file verify that their contents are UTF-8? 139inline bool HasUtf8Verification(const FileDescriptor* file) { 140 return file->options().optimize_for() != FileOptions::LITE_RUNTIME; 141} 142 143// Should we generate a separate, super-optimized code path for serializing to 144// flat arrays? We don't do this in Lite mode because we'd rather reduce code 145// size. 146inline bool HasFastArraySerialization(const FileDescriptor* file) { 147 return file->options().optimize_for() == FileOptions::SPEED; 148} 149 150 151} // namespace cpp 152} // namespace compiler 153} // namespace protobuf 154 155} // namespace google 156#endif // GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__ 157