C++ Reference on Protocol Buffers Documentation

arena.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/arena.h> namespace google::protobuf This file defines an Arena allocator for better allocation performance. Classes in this fileArenaOptionsArenaOptions provides optional additional parameters to arena construction that control its block-allocation behavior. ArenaArena allocator. Arena::InternalHelperArena::is_arena_constructableHelper typetraits that indicates support for arenas in a type T at compile time. Arena::is_destructor_skippablestruct ArenaOptions#include <google/protobuf/arena.h> namespace google::protobuf ArenaOptions provides optional additional parameters to arena construction that control its block-allocation behavior. Memberssize_tstart_block_sizeThis defines the size of the first block requested from the system malloc.

common.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/stubs/common.h> namespace google::protobuf Contains basic types and utilities used by the rest of the library. Classes in this file

code_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/code_generator.h> namespace google::protobuf::compiler Defines the abstract interface implemented by each of the language-specific code generators. Classes in this fileCodeGeneratorThe abstract interface to a class which generates code implementing a particular proto file in a particular language. GeneratorContextCodeGenerators generate one or more files in a given directory. File MembersThese definitions are not part of any class.typedefGeneratorContext OutputDirectoryThe type GeneratorContext was once called OutputDirectory. more...voidParseGeneratorParameter(const std::string & , std::vector< std::pair< std::string, std::string > > * )Several code generators treat the parameter argument as holding a list of options separated by commas.

command_line_interface.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/command_line_interface.h> namespace google::protobuf::compiler Implements the Protocol Compiler front-end such that it may be reused by custom compilers written to support other languages. Classes in this fileCommandLineInterfaceThis class implements the command-line interface to the protocol compiler. class CommandLineInterface#include <google/protobuf/compiler/command_line_interface.h> namespace google::protobuf::compiler This class implements the command-line interface to the protocol compiler. It is designed to make it very easy to create a custom protocol compiler supporting the languages of your choice.

cpp_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/cpp/cpp_generator.h> namespace google::protobuf::compiler::cpp Generates C++ code for a given .proto file. Classes in this fileCppGeneratorCodeGenerator implementation which generates a C++ source file and header. class CppGenerator: public CodeGenerator#include <google/protobuf/compiler/cpp/cpp_generator.h> namespace google::protobuf::compiler::cpp CodeGenerator implementation which generates a C++ source file and header. If you create your own protocol compiler binary and you want it to support C++ output, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function.

csharp_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/csharp/csharp_generator.h> namespace google::protobuf::compiler::csharp Generates C# code for a given .proto file. Classes in this fileGeneratorCodeGenerator implementation which generates a C# source file and header. class Generator: public CodeGenerator#include <google/protobuf/compiler/csharp/csharp_generator.h> namespace google::protobuf::compiler::csharp CodeGenerator implementation which generates a C# source file and header. If you create your own protocol compiler binary and you want it to support C# output, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function.

csharp_names.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/csharp/csharp_names.h> namespace google::protobuf::compiler::csharp Provides a mechanism for mapping a descriptor to the fully-qualified name of the corresponding C# class. Classes in this fileFile MembersThese definitions are not part of any class.std::stringGetFileNamespace(const FileDescriptor * descriptor)Requires: more...std::stringGetClassName(const Descriptor * descriptor)Requires: more...std::stringGetReflectionClassName(const FileDescriptor * descriptor)Requires: more...std::stringGetOutputFile(const FileDescriptor * descriptor, const std::string file_extension, const bool generate_directories, const std::string base_namespace, std::string * error)Generates output file name for given file descriptor. more... std::string csharp::GetFileNamespace( const FileDescriptor * descriptor)Requires: descriptor !

importer.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/importer.h> namespace google::protobuf::compiler This file is the public interface to the .proto file parser. Classes in this fileSourceTreeDescriptorDatabaseAn implementation of DescriptorDatabase which loads files from a SourceTree and parses them. ImporterSimple interface for parsing .proto files. MultiFileErrorCollectorIf the importer encounters problems while trying to import the proto files, it reports them to a MultiFileErrorCollector. SourceTreeAbstract interface which represents a directory tree containing proto files. DiskSourceTreeAn implementation of SourceTree which loads files from locations on disk.

java_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/java/java_generator.h> namespace google::protobuf::compiler::java Generates Java code for a given .proto file. Classes in this fileJavaGeneratorCodeGenerator implementation which generates Java code. class JavaGenerator: public CodeGenerator#include <google/protobuf/compiler/java/java_generator.h> namespace google::protobuf::compiler::java CodeGenerator implementation which generates Java code. If you create your own protocol compiler binary and you want it to support Java output, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function. MembersJavaGenerator()~JavaGenerator()implements CodeGeneratorvirtual boolGenerate(const FileDescriptor * file, const std::string & parameter, GeneratorContext * generator_context, std::string * error) constGenerates code for the given proto file, generating one or more files in the given output directory.

java_names.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/java/java_names.h> namespace google::protobuf::compiler::java Provides a mechanism for mapping a descriptor to the fully-qualified name of the corresponding Java class. Classes in this fileFile MembersThese definitions are not part of any class.std::stringClassName(const Descriptor * descriptor)Requires: more...std::stringClassName(const EnumDescriptor * descriptor)Requires: more...std::stringClassName(const FileDescriptor * descriptor)Requires: more...std::stringClassName(const ServiceDescriptor * descriptor)Requires: more...std::stringFileJavaPackage(const FileDescriptor * descriptor)Requires: more...std::stringCapitalizedFieldName(const FieldDescriptor * descriptor)Requires: more... std::string java::ClassName( const Descriptor * descriptor)Requires: descriptor != NULL Returns: The fully-qualified Java class name.

javanano_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/javanano/javanano_generator.h> namespace google::protobuf::compiler::javanano Generates Java nano code for a given .proto file. Classes in this fileJavaNanoGeneratorCodeGenerator implementation which generates Java nano code. class JavaNanoGenerator: public CodeGenerator#include <google/protobuf/compiler/javanano/javanano_generator.h> namespace google::protobuf::compiler::javanano CodeGenerator implementation which generates Java nano code. If you create your own protocol compiler binary and you want it to support Java output for the nano runtime, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function.

js_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/js/js_generator.h> namespace google::protobuf::compiler::js Generates JavaScript code for a given .proto file. Classes in this fileGeneratorOptionsGeneratorCodeGenerator implementation which generates a JavaScript source file and header. struct GeneratorOptions#include <google/protobuf/compiler/js/js_generator.h> namespace google::protobuf::compiler::js MembersenumImportStyleWhat style of imports should be used. more...enumOutputMode more...std::stringoutput_dirOutput path. std::stringnamespace_prefixNamespace prefix. boolbinaryEnable binary-format support? enum google::protobuf::compiler::js::GeneratorOptions::ImportStyleimport_stylebooladd_require_for_enumsAdd a goog.requires() call for each enum type used. more...booltestonlySet this as a test-only module via goog.setTestOnly();. std::stringlibraryCreate a library with name <name>_lib.js rather than a separate .

objectivec_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/objectivec/objectivec_generator.h> namespace google::protobuf::compiler::objectivec Generates ObjectiveC code for a given .proto file. Classes in this fileObjectiveCGeneratorCodeGenerator implementation which generates a ObjectiveC source file and header. class ObjectiveCGenerator: public CodeGenerator#include <google/protobuf/compiler/objectivec/objectivec_generator.h> namespace google::protobuf::compiler::objectivec CodeGenerator implementation which generates a ObjectiveC source file and header. If you create your own protocol compiler binary and you want it to support ObjectiveC output, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function.

objectivec_helpers.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/objectivec/objectivec_helpers.h> namespace google::protobuf::compiler::objectivec Helper functions for generating ObjectiveC code. Classes in this fileOptionsGenerator options (see objectivec_generator.cc for a description of each): TextFormatDecodeDataGenerate decode data needed for ObjC's GPBDecodeTextFormatName() to transform the input into the expected output. LineConsumerHelper for parsing simple files. ImportWriterHelper class for parsing framework import mappings and generating import statements. File MembersThese definitions are not part of any class.enumObjectiveCType more...enumFlagType more...const char *constProtobufLibraryFrameworkNameThe name the commonly used by the library when built as a framework.

parser.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/parser.h> namespace google::protobuf::compiler Implements parsing of .proto files to FileDescriptorProtos. Classes in this fileParserImplements parsing of protocol definitions (such as .proto files). SourceLocationTableA table mapping (descriptor, ErrorLocation) pairs – as reported by DescriptorPool when validating descriptors – to line and column numbers within the original source code. class Parser#include <google/protobuf/compiler/parser.h> namespace google::protobuf::compiler Implements parsing of protocol definitions (such as .proto files). Note that most users will be more interested in the Importer class.

plugin.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/plugin.h> namespace google::protobuf::compiler Front-end for protoc code generator plugins written in C++. To implement a protoc plugin in C++, simply write an implementation of CodeGenerator, then create a main() function like: int main(int argc, char* argv[]) { MyCodeGenerator generator; return google::protobuf::compiler::PluginMain(argc, argv, &generator); } You must link your plugin against libprotobuf and libprotoc. The core part of PluginMain is to invoke the given CodeGenerator on a CodeGeneratorRequest to generate a CodeGeneratorResponse.

plugin.pb.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/plugin.pb.h> namespace google::protobuf::compiler API for protoc plugins. This file defines a set of protocol message classes which make up the API to protoc code generator plugins. Plugins written in C++ should probably build on the API in plugin.h instead of dealing with the protobuf-level API, but plugins in other languages will need to deal with the raw messages as defined below. The protocol compiler currently doesn't support auto-generated documentation, hence this page contains no descriptions.

python_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/python/python_generator.h> namespace google::protobuf::compiler::python Generates Python code for a given .proto file. Classes in this fileGeneratorCodeGenerator implementation for generated Python protocol buffer classes. class Generator: public CodeGenerator#include <google/protobuf/compiler/python/python_generator.h> namespace google::protobuf::compiler::python CodeGenerator implementation for generated Python protocol buffer classes. If you create your own protocol compiler binary and you want it to support Python output, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function.

ruby_generator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/compiler/ruby/ruby_generator.h> namespace google::protobuf::compiler::ruby Generates Ruby code for a given .proto file. Classes in this fileGeneratorCodeGenerator implementation for generated Ruby protocol buffer classes. class Generator: public CodeGenerator#include <google/protobuf/compiler/ruby/ruby_generator.h> namespace google::protobuf::compiler::ruby CodeGenerator implementation for generated Ruby protocol buffer classes. If you create your own protocol compiler binary and you want it to support Ruby output, you can do so by registering an instance of this CodeGenerator with the CommandLineInterface in your main() function.

descriptor.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/descriptor.h> namespace google::protobuf This file contains classes which describe a type of protocol message. You can use a message's descriptor to learn at runtime what fields it contains and what the types of those fields are. The Message interface also allows you to dynamically access and modify individual fields by passing the FieldDescriptor of the field you are interested in. Most users will not care about descriptors, because they will write code specific to certain protocol types and will simply use the classes generated by the protocol compiler directly.

descriptor.pb.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/descriptor.pb.h> namespace google::protobuf Protocol buffer representations of descriptors. This file defines a set of protocol message classes which represent the same information represented by the classes defined in descriptor.h. You can convert a FileDescriptorProto to a FileDescriptor using the DescriptorPool class. Thus, the classes in this file allow protocol type definitions to be communicated efficiently between processes. The protocol compiler currently doesn't support auto-generated documentation, hence this page contains no descriptions.

descriptor_database.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/descriptor_database.h> namespace google::protobuf Interface for manipulating databases of descriptors. Classes in this fileDescriptorDatabaseAbstract interface for a database of descriptors. SimpleDescriptorDatabaseA DescriptorDatabase into which you can insert files manually. EncodedDescriptorDatabaseVery similar to SimpleDescriptorDatabase, but stores all the descriptors as raw bytes and generally tries to use as little memory as possible. DescriptorPoolDatabaseA DescriptorDatabase that fetches files from a given pool. MergedDescriptorDatabaseA DescriptorDatabase that wraps two or more others. class DescriptorDatabase#include <google/protobuf/descriptor_database.

dynamic_message.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/dynamic_message.h> namespace google::protobuf Defines an implementation of Message which can emulate types which are not known at compile-time. Classes in this fileDynamicMessageFactoryConstructs implementations of Message which can emulate types which are not known at compile-time. DynamicMapSorterHelper for computing a sorted list of map entries via reflection. class DynamicMessageFactory: public MessageFactory#include <google/protobuf/dynamic_message.h> namespace google::protobuf Constructs implementations of Message which can emulate types which are not known at compile-time. Sometimes you want to be able to manipulate protocol types that you don't know about at compile time.

coded_stream.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/coded_stream.h> namespace google::protobuf::io This file contains the CodedInputStream and CodedOutputStream classes, which wrap a ZeroCopyInputStream or ZeroCopyOutputStream, respectively, and allow you to read or write individual pieces of data in various formats. In particular, these implement the varint encoding for integers, a simple variable-length encoding in which smaller numbers take fewer bytes. Typically these classes will only be used internally by the protocol buffer library in order to encode and decode protocol buffers.

gzip_stream.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/gzip_stream.h> namespace google::protobuf::io This file contains the definition for classes GzipInputStream and GzipOutputStream. GzipInputStream decompresses data from an underlying ZeroCopyInputStream and provides the decompressed data as a ZeroCopyInputStream. GzipOutputStream is an ZeroCopyOutputStream that compresses data to an underlying ZeroCopyOutputStream. Classes in this fileGzipInputStreamA ZeroCopyInputStream that reads compressed data through zlib. GzipOutputStreamGzipOutputStream::Optionsclass GzipInputStream: public ZeroCopyInputStream#include <google/protobuf/io/gzip_stream.h> namespace google::protobuf::io A ZeroCopyInputStream that reads compressed data through zlib. MembersenumFormatFormat key for constructor. more.

printer.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/printer.h> namespace google::protobuf::io Utility class for writing text to a ZeroCopyOutputStream. Classes in this fileAnnotationCollectorRecords annotations about a Printer's output. AnnotationProtoCollectorRecords annotations about a Printer's output to the given protocol buffer, assuming that the buffer has an ::Annotation message exposing path, source_file, begin and end fields. Printerclass AnnotationCollector#include <google/protobuf/io/printer.h> namespace google::protobuf::io Records annotations about a Printer's output. Known subclasses: AnnotationProtoCollector< AnnotationProto >Memberstypedefstd::pair< std::pair< size_t, size_t >, std::string > AnnotationAnnotation is a offset range and a payload pair.

tokenizer.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/tokenizer.h> namespace google::protobuf::io Class for parsing tokenized text from a ZeroCopyInputStream. Classes in this fileErrorCollectorAbstract interface for an object which collects the errors that occur during parsing. TokenizerThis class converts a stream of raw text into a stream of tokens for the protocol definition parser to parse. Tokenizer::TokenStructure representing a token read from the token stream. File MembersThese definitions are not part of any class.typedefint ColumnNumberBy "column number", the proto compiler refers to a count of the number of bytes before a given byte, except that a tab character advances to the next multiple of 8 bytes.

zero_copy_stream.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/zero_copy_stream.h> namespace google::protobuf::io This file contains the ZeroCopyInputStream and ZeroCopyOutputStream interfaces, which represent abstract I/O streams to and from which protocol buffers can be read and written. For a few simple implementations of these interfaces, see zero_copy_stream_impl.h. These interfaces are different from classic I/O streams in that they try to minimize the amount of data copying that needs to be done. To accomplish this, responsibility for allocating buffers is moved to the stream object, rather than being the responsibility of the caller.

zero_copy_stream_impl.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/zero_copy_stream_impl.h> namespace google::protobuf::io This file contains common implementations of the interfaces defined in zero_copy_stream.h which are only included in the full (non-lite) protobuf library. These implementations include Unix file descriptors and C++ iostreams. See also: zero_copy_stream_impl_lite.h Classes in this fileFileInputStreamA ZeroCopyInputStream which reads from a file descriptor. FileOutputStreamA ZeroCopyOutputStream which writes to a file descriptor. IstreamInputStreamA ZeroCopyInputStream which reads from a C++ istream. OstreamOutputStreamA ZeroCopyOutputStream which writes to a C++ ostream.

zero_copy_stream_iml_lite.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/io/zero_copy_stream_impl_lite.h> namespace google::protobuf::io This file contains common implementations of the interfaces defined in zero_copy_stream.h which are included in the "lite" protobuf library. These implementations cover I/O on raw arrays and strings, as well as adaptors which make it easy to implement streams based on traditional streams. Of course, many users will probably want to write their own implementations of these interfaces specific to the particular I/O abstractions they prefer to use, but these should cover the most common cases.

map.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/map.h> namespace google::protobuf This file defines the map container and its helpers to support protobuf maps. The Map and MapIterator types are provided by this header file. Please avoid using other types defined here, unless they are public types within Map or MapIterator, such as Map::value_type. Classes in this fileMapPairThis is the class for Map's internal value_type. MapMap is an associative container type used to store protobuf map fields. Map::const_iteratorIterators.

message.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/message.h> namespace google::protobuf Defines Message, the abstract interface implemented by non-lite protocol message objects. Although it's possible to implement this interface manually, most users will use the protocol compiler to generate implementations. Example usage: Say you have a message defined as: message Foo { optional string text = 1; repeated int32 numbers = 2; } Then, if you used the protocol compiler to generate a class from the above definition, you could use it like so:

message_lite.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/message_lite.h> namespace google::protobuf Defines MessageLite, the abstract interface implemented by all (lite and non-lite) protocol message objects. Classes in this fileMessageLiteInterface to light weight protocol messages. File MembersThese definitions are not part of any class.voidShutdownProtobufLibrary()Shut down the entire protocol buffers library, deleting all static-duration objects allocated by the library or by generated .pb.cc files. more... void protobuf::ShutdownProtobufLibrary()Shut down the entire protocol buffers library, deleting all static-duration objects allocated by the library or by generated .

repeated_field.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/repeated_field.h> namespace google::protobuf RepeatedField and RepeatedPtrField are used by generated protocol message classes to manipulate repeated fields. These classes are very similar to STL's vector, but include a number of optimizations found to be useful specifically in the case of Protocol Buffers. RepeatedPtrField is particularly different from STL vector as it manages ownership of the pointers that it contains. Typically, clients should not need to access RepeatedField objects directly, but should instead use the accessor functions generated automatically by the protocol compiler.

service.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/service.h> namespace google::protobuf DEPRECATED: This module declares the abstract interfaces underlying proto2 RPC services. These are intended to be independent of any particular RPC implementation, so that proto2 services can be used on top of a variety of implementations. Starting with version 2.3.0, RPC implementations should not try to build on these, but should instead provide code generator plugins which generate code specific to the particular RPC implementation. This way the generated code can be more appropriate for the implementation in use and can avoid unnecessary layers of indirection.

text_format.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/text_format.h> namespace google::protobuf Utilities for printing and parsing protocol messages in a human-readable, text-based format. Classes in this fileTextFormatThis class implements protocol buffer text format, colloquially known as text proto. TextFormat::BaseTextGeneratorTextFormat::FastFieldValuePrinterThe default printer that converts scalar values from fields into their string representation. TextFormat::FieldValuePrinterDeprecated: please use FastFieldValuePrinter instead. TextFormat::FinderInterface that Printers or Parsers can use to find extensions, or types referenced in Any messages. TextFormat::MessagePrinterTextFormat::ParseInfoTreeData structure which is populated with the locations of each field value parsed from the text.

unknown_field_set.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/unknown_field_set.h> namespace google::protobuf Contains classes used to keep track of unrecognized fields seen while parsing a protocol message. Classes in this fileUnknownFieldSetAn UnknownFieldSet contains fields that were encountered while parsing a message but were not defined by its type. UnknownFieldRepresents one field in an UnknownFieldSet. UnknownField::LengthDelimitedclass UnknownFieldSet#include <google/protobuf/unknown_field_set.h> namespace google::protobuf An UnknownFieldSet contains fields that were encountered while parsing a message but were not defined by its type. Keeping track of these can be useful, especially in that they may be written if the message is serialized again without being cleared in between.

field_comparator.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/field_comparator.h> namespace google::protobuf::util Defines classes for field comparison. Classes in this fileFieldComparatorBase class specifying the interface for comparing protocol buffer fields. SimpleFieldComparatorBasic implementation of FieldComparator. DefaultFieldComparatorclass FieldComparator#include <google/protobuf/util/field_comparator.h> namespace google::protobuf::util Base class specifying the interface for comparing protocol buffer fields. Regular users should consider using or subclassing DefaultFieldComparator rather than this interface. Currently, this does not support comparing unknown fields. Known subclasses: SimpleFieldComparatorMembersenumComparisonResult more...FieldComparator()virtual ~FieldComparator()virtual ComparisonResultCompare(const Message & message_1, const Message & message_2, const FieldDescriptor * field, int index_1, int index_2, const util::FieldContext * field_context) = 0Compares the values of a field in two protocol buffer messages.

field_mask_util.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/field_mask_util.h> namespace google::protobuf::util Defines utilities for the FieldMask well known type. Classes in this fileFieldMaskUtilFieldMaskUtil::MergeOptionsFieldMaskUtil::TrimOptionsclass FieldMaskUtil#include <google/protobuf/util/field_mask_util.h> namespace google::protobuf::util Membersstatic std::stringToString(const FieldMask & mask)Converts FieldMask to/from string, formatted by separating each path with a comma (e.g., "foo_bar,baz.quz"). static voidFromString(StringPiece str, FieldMask * out)template static voidFromFieldNumbers(const std::vector< int64_t > & field_numbers, FieldMask * out)Populates the FieldMask with the paths corresponding to the fields with the given numbers, after checking that all field numbers are valid.

json_util.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/json_util.h> namespace google::protobuf::util Utility functions to convert between protobuf binary format and proto3 JSON format. Classes in this fileJsonParseOptionsJsonPrintOptionsFile MembersThese definitions are not part of any class.typedefJsonPrintOptions JsonOptionsDEPRECATED. Use JsonPrintOptions instead. util::StatusMessageToJsonString(const Message & message, std::string * output, const JsonOptions & options)Converts from protobuf message to JSON and appends it to |output|. more...util::StatusMessageToJsonString(const Message & message, std::string * output)util::StatusJsonStringToMessage(StringPiece input, Message * message, const JsonParseOptions & options)Converts from JSON to protobuf message.

message_differencer.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/message_differencer.h> namespace google::protobuf::util This file defines static methods and classes for comparing Protocol Messages. Aug. 2008: Added Unknown Fields Comparison for messages. Aug. 2009: Added different options to compare repeated fields. Apr. 2010: Moved field comparison to FieldComparator Sep. 2020: Added option to output map keys in path Classes in this fileMessageDifferencerA basic differencer that can be used to determine the differences between two specified Protocol Messages. MessageDifferencer::IgnoreCriteriaAbstract base class from which all IgnoreCriteria derive.

time_util.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/time_util.h> namespace google::protobuf::util Defines utilities for the Timestamp and Duration well known types. Classes in this fileTimeUtilUtility functions for Timestamp and Duration. class TimeUtil#include <google/protobuf/util/time_util.h> namespace google::protobuf::util Utility functions for Timestamp and Duration. Membersconst int64_tkTimestampMinSeconds = = -62135596800LLThe min/max Timestamp/Duration values we support. more...const int64_tkTimestampMaxSeconds = = 253402300799LLFor "9999-12-31T23:59:59.999999999Z". const int64_tkDurationMinSeconds = = -315576000000LLconst int64_tkDurationMaxSeconds = = 315576000000LLstatic std::stringToString(const Timestamp & timestamp)Converts Timestamp to/from RFC 3339 date string format. more.

type_resolver.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/type_resolver.h> namespace google::protobuf::util Defines a TypeResolver for the Any message. Classes in this fileTypeResolverAbstract interface for a type resolver. class TypeResolver#include <google/protobuf/util/type_resolver.h> namespace google::protobuf::util Abstract interface for a type resolver. Implementations of this interface must be thread-safe. MembersTypeResolver()virtual ~TypeResolver()virtual util::StatusResolveMessageType(const std::string & type_url, google::protobuf::Type * message_type) = 0Resolves a type url for a message type. virtual util::StatusResolveEnumType(const std::string & type_url, google::protobuf::Enum * enum_type) = 0Resolves a type url for an enum type.

type_resolver_util.h

Mon, 01 Jan 0001 00:00:00 +0000

#include <google/protobuf/util/type_resolver_util.h> namespace google::protobuf::util Defines utilities for the TypeResolver. Classes in this fileFile MembersThese definitions are not part of any class.TypeResolver *NewTypeResolverForDescriptorPool(const std::string & url_prefix, const DescriptorPool * pool)Creates a TypeResolver that serves type information in the given descriptor pool. more... TypeResolver * util::NewTypeResolverForDescriptorPool( const std::string & url_prefix, const DescriptorPool * pool)Creates a TypeResolver that serves type information in the given descriptor pool. Caller takes ownership of the returned TypeResolver.