Rules
proto_lang_toolchain
View rule sourceproto_lang_toolchain(name, blacklisted_protos, command_line, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, features, licenses, mnemonic, output_files, plugin, plugin_format_flag, progress_message, proto_compiler, restricted_to, runtime, tags, target_compatible_with, testonly, visibility)
If using Bazel, please load the rule from https://github.com/bazelbuild/rules_proto.
Specifies how a LANG_proto_library rule (e.g., java_proto_library) should invoke the
proto-compiler.
Some LANG_proto_library rules allow specifying which toolchain to use using command-line flags;
consult their documentation.
Normally you should not write those kind of rules unless you want to tune your Java compiler.
There's no compiler. The proto-compiler is taken from the proto_library rule we attach to. It is
passed as a command-line flag to Blaze.
Several features require a proto-compiler to be invoked on the proto_library rule itself.
It's beneficial to enforce the compiler that LANG_proto_library uses is the same as the one
proto_library does.
Examples
A simple example would be:
proto_lang_toolchain(
    name = "javalite_toolchain",
    command_line = "--javalite_out=shared,immutable:$(OUT)",
    plugin = ":javalite_plugin",
    runtime = ":protobuf_lite",
)
Arguments
| Attributes | |
|---|---|
name | 
        
           Name; required A unique name for this target.  | 
      
          blacklisted_protos
         | 
        
                     List of labels; default is  srcs attribute of
        blacklisted_protos.
        This is used for .proto files that are already linked into proto runtimes, such as
        any.proto.
         | 
      
          command_line
         | 
        
                     String; required This value will be passed to proto-compiler to generate the code. Only include the parts specific to this code-generator/plugin (e.g., do not include -I parameters)
  | 
      
          mnemonic
         | 
        
                     String; default is   | 
      
          output_files
         | 
        
                     String; default is  $(OUT) in command_line is formatted, either by
        a path to a single file or output directory in case of multiple files.
        Possible values are: "single", "multiple".
         | 
      
          plugin
         | 
        
                     Label; default is  --plugin=protoc-gen-PLUGIN=<executable>.
         | 
      
          plugin_format_flag
         | 
        
                     String; default is  --plugin=protoc-gen-PLUGIN=<executable>.
         | 
      
          progress_message
         | 
        
                     String; default is   | 
      
          proto_compiler
         | 
        
                     Label; default is   | 
      
          runtime
         | 
        
                     Label; default is   | 
      
proto_library
View rule sourceproto_library(name, deps, srcs, data, allow_exports, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, exports, features, import_prefix, licenses, restricted_to, strip_import_prefix, tags, target_compatible_with, testonly, visibility)
Deprecated. Please use https://github.com/bazelbuild/rules_proto instead.
Use proto_library to define libraries of protocol buffers
   which may be used from multiple languages. A proto_library may be listed
   in the deps clause of supported rules, such as java_proto_library.
When compiled on the command-line, a proto_library creates a file named
   foo-descriptor-set.proto.bin, which is the descriptor set for the
   messages the rule srcs. The file is a serialized FileDescriptorSet, which is
   described in
   
   https://developers.google.com/protocol-buffers/docs/techniques#self-description.
It only contains information about the .proto files directly mentioned by a
proto_library rule; the collection of transitive descriptor sets is available through
the [ProtoInfo].transitive_descriptor_sets Starlark provider.
See documentation in ProtoInfo.java.
Recommended code organization:
-  One 
proto_libraryrule per.protofile. -  A file named 
foo.protowill be in a rule namedfoo_proto, which is located in the same package. -  A 
[language]_proto_librarythat wraps aproto_librarynamedfoo_protoshould be calledfoo_[language]_proto, and be located in the same package. 
Arguments
| Attributes | |
|---|---|
name | 
        
           Name; required A unique name for this target.  | 
      
          deps
         | 
        
                     List of labels; default is  proto_library rules that the target depends upon.
        A proto_library may only depend on other
        proto_library targets.
        It may not depend on language-specific libraries.
         | 
      
          srcs
         | 
        
                     List of labels; default is  .proto and .protodevel files that are
        processed to create the target. This is usually a non empty list. One usecase
        where srcs can be empty is an alias-library. This is a
        proto_library rule having one or more other proto_library in deps.
        This pattern can be used to e.g. export a public api under a persistent name.
         | 
      
          allow_exports
         | 
        
                     Label; default is   | 
      
          exports
         | 
        
                     List of labels; default is   | 
      
          import_prefix
         | 
        
                     String; default is  When set, the .proto source files in the  The prefix in the   | 
      
          strip_import_prefix
         | 
        
                     String; default is  When set, .proto source files in the  If it's a relative path (not starting with a slash), it's taken as a package-relative one. If it's an absolute one, it's understood as a repository-relative path. The prefix in the   |