protoc

compile protocol buffer description files

TLDR

Generate Python code from a .proto file

$ protoc --python_out=[path/to/output_directory] [input_file.proto]
copy

Generate Java code from a .proto file that imports other .proto files

$ protoc --java_out=[path/to/output_directory] --proto_path=[path/to/import_search_path] [input_file.proto]
copy

Generate code for multiple languages

$ protoc --csharp_out=[path/to/c#_output_directory] --js_out=[path/to/js_output_directory] [input_file.proto]
copy

Help

Usage: protoc [OPTION] PROTO_FILES 
Parse PROTO_FILES and generate output based on the options given:
  -IPATH, --proto_path=PATH   Specify the directory in which to search for 
                              imports.  May be specified multiple times; 
                              directories will be searched in order.  If not 
                              given, the current working directory is used. 
                              If not found in any of the these directories, 
                              the --descriptor_set_in descriptors will be 
                              checked for required proto file. 
  --version                   Show version info and exit. 
  -h, --help                  Show this text and exit. 
  --encode=MESSAGE_TYPE       Read a text-format message of the given type 
                              from standard input and write it in binary 
                              to standard output.  The message type must 
                              be defined in PROTO_FILES or their imports. 
  --deterministic_output      When using --encode, ensure map fields are 
                              deterministically ordered. Note that this order 
                              is not canonical, and changes across builds or 
                              releases of protoc. 
  --decode=MESSAGE_TYPE       Read a binary message of the given type from 
                              standard input and write it in text format 
                              to standard output.  The message type must 
                              be defined in PROTO_FILES or their imports. 
  --decode_raw                Read an arbitrary protocol message from 
                              standard input and write the raw tag/value 
                              pairs in text format to standard output.  No 
                              PROTO_FILES should be given when using this 
                              flag. 
  --descriptor_set_in=FILES   Specifies a delimited list of FILES 
                              each containing a FileDescriptorSet (a 
                              protocol buffer defined in descriptor.proto). 
                              The FileDescriptor for each of the PROTO_FILES 
                              provided will be loaded from these 
                              FileDescriptorSets. If a FileDescriptor 
                              appears multiple times, the first occurrence 
                              will be used. 
  -oFILE,                     Writes a FileDescriptorSet (a protocol buffer, 
    --descriptor_set_out=FILE defined in descriptor.proto) containing all of 
                              the input files to FILE. 
  --include_imports           When using --descriptor_set_out, also include 
                              all dependencies of the input files in the 
                              set, so that the set is self-contained. 
  --include_source_info       When using --descriptor_set_out, do not strip 
                              SourceCodeInfo from the FileDescriptorProto. 
                              This results in vastly larger descriptors that 
                              include information about the original 
                              location of each decl in the source file as 
                              well as surrounding comments. 
  --dependency_out=FILE       Write a dependency output file in the format 
                              expected by make. This writes the transitive 
                              set of input file paths to FILE 
  --error_format=FORMAT       Set the format in which to print errors. 
                              FORMAT may be 'gcc' (the default) or 'msvs' 
                              (Microsoft Visual Studio format). 
  --print_free_field_numbers  Print the free field numbers of the messages 
                              defined in the given proto files. Groups share 
                              the same field number space with the parent 
                              message. Extension ranges are counted as 
                              occupied fields numbers. 
  --plugin=EXECUTABLE         Specifies a plugin executable to use. 
                              Normally, protoc searches the PATH for 
                              plugins, but you may specify additional 
                              executables not in the path using this flag. 
                              Additionally, EXECUTABLE may be of the form 
                              NAME=PATH, in which case the given plugin name 
                              is mapped to the given executable even if 
                              the executable's own name differs. 
  --cpp_out=OUT_DIR           Generate C++ header and source. 
  --csharp_out=OUT_DIR        Generate C# source file. 
  --java_out=OUT_DIR          Generate Java source file. 
  --js_out=OUT_DIR            Generate JavaScript source. 
  --objc_out=OUT_DIR          Generate Objective-C header and source. 
  --php_out=OUT_DIR           Generate PHP source file. 
  --python_out=OUT_DIR        Generate Python source file. 
  --ruby_out=OUT_DIR          Generate Ruby source file. 
  @                 Read options and filenames from file. If a 
                              relative file path is specified, the file 
                              will be searched in the working directory. 
                              The --proto_path option will not affect how 
                              this argument file is searched. Content of 
                              the file will be expanded in the position of 
                              @ as in the argument list. Note 
                              that shell expansion is not applied to the 
                              content of the file (i.e., you cannot use 
                              quotes, wildcards, escapes, commands, etc.). 
                              Each line corresponds to a single argument, 
                              even if it contains spaces. 

Copied to clipboard
Cake Defi