Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/src/google/protobuf/compiler/command_line_interface.h

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 37 matching lines @@
 
 namespace google {
 namespace protobuf {
 
 class Descriptor;            // descriptor.h
 class DescriptorPool;        // descriptor.h
 class FileDescriptor;        // descriptor.h
 class FileDescriptorProto;   // descriptor.pb.h
 template<typename T> class RepeatedPtrField;  // repeated_field.h
 
-}  // namespace protobuf
-
-namespace protobuf {
 namespace compiler {
 
 class CodeGenerator;        // code_generator.h
 class GeneratorContext;      // code_generator.h
 class DiskSourceTree;       // importer.h
 
 // 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.  For example, if you wanted to
 // create a custom protocol compiler binary which includes both the regular
@@ skipping 66 matching lines @@
   //
   // The compiler determines the executable name to search for by concatenating
   // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
   // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
   // the compiler will try to run the program "protoc-foo".
   //
   // The plugin program should implement the following usage:
   //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
   // --out indicates the output directory (as passed to the --foo_out
   // parameter); if omitted, the current directory should be used.  --parameter
-  // gives the generator parameter, if any was provided (see below).  The
-  // PROTO_FILES list the .proto files which were given on the compiler
-  // command-line; these are the files for which the plugin is expected to
-  // generate output code.  Finally, DESCRIPTORS is an encoded FileDescriptorSet
-  // (as defined in descriptor.proto).  This is piped to the plugin's stdin.
-  // The set will include descriptors for all the files listed in PROTO_FILES as
-  // well as all files that they import.  The plugin MUST NOT attempt to read
-  // the PROTO_FILES directly -- it must use the FileDescriptorSet.
+  // gives the generator parameter, if any was provided.  The PROTO_FILES list
+  // the .proto files which were given on the compiler command-line; these are
+  // the files for which the plugin is expected to generate output code.
+  // Finally, DESCRIPTORS is an encoded FileDescriptorSet (as defined in
+  // descriptor.proto).  This is piped to the plugin's stdin.  The set will
+  // include descriptors for all the files listed in PROTO_FILES as well as
+  // all files that they import.  The plugin MUST NOT attempt to read the
+  // PROTO_FILES directly -- it must use the FileDescriptorSet.
   //
   // The plugin should generate whatever files are necessary, as code generators
   // normally do.  It should write the names of all files it generates to
   // stdout.  The names should be relative to the output directory, NOT absolute
   // names or relative to the current directory.  If any errors occur, error
   // messages should be written to stderr.  If an error is fatal, the plugin
   // should exit with a non-zero exit code.
-  //
-  // Plugins can have generator parameters similar to normal built-in
-  // generators. Extra generator parameters can be passed in via a matching
-  // "_opt" parameter. For example:
-  //   protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz
-  // This will pass "enable_bar,enable_baz" as the parameter to the plugin.
-  //
   void AllowPlugins(const string& exe_name_prefix);
 
   // Run the Protocol Compiler with the given command-line parameters.
   // Returns the error code which should be returned by main().
   //
   // It may not be safe to call Run() in a multi-threaded environment because
   // it calls strerror().  I'm not sure why you'd want to do this anyway.
   int Run(int argc, const char* const argv[]);
 
   // Call SetInputsAreCwdRelative(true) if the input files given on the command
@@ skipping 59 matching lines @@
 
   // Interprets arguments parsed with ParseArgument.
   ParseArgumentStatus InterpretArgument(const string& name,
                                         const string& value);
 
   // Print the --help text to stderr.
   void PrintHelpText();
 
   // Generate the given output file from the given input.
   struct OutputDirective;  // see below
-  bool GenerateOutput(const std::vector<const FileDescriptor*>& parsed_files,
+  bool GenerateOutput(const vector<const FileDescriptor*>& parsed_files,
                       const OutputDirective& output_directive,
                       GeneratorContext* generator_context);
-  bool GeneratePluginOutput(
-      const std::vector<const FileDescriptor*>& parsed_files,
-      const string& plugin_name, const string& parameter,
-      GeneratorContext* generator_context, string* error);
+  bool GeneratePluginOutput(const vector<const FileDescriptor*>& parsed_files,
+                            const string& plugin_name,
+                            const string& parameter,
+                            GeneratorContext* generator_context,
+                            string* error);
 
   // Implements --encode and --decode.
   bool EncodeOrDecode(const DescriptorPool* pool);
 
   // Implements the --descriptor_set_out option.
-  bool WriteDescriptorSet(
-      const std::vector<const FileDescriptor*> parsed_files);
+  bool WriteDescriptorSet(const vector<const FileDescriptor*> parsed_files);
 
   // Implements the --dependency_out option
   bool GenerateDependencyManifestFile(
-      const std::vector<const FileDescriptor*>& parsed_files,
+      const vector<const FileDescriptor*>& parsed_files,
       const GeneratorContextMap& output_directories,
       DiskSourceTree* source_tree);
 
   // Get all transitive dependencies of the given file (including the file
   // itself), adding them to the given list of FileDescriptorProtos.  The
   // protos will be ordered such that every file is listed before any file that
   // depends on it, so that you can call DescriptorPool::BuildFile() on them
   // in order.  Any files in *already_seen will not be added, and each file
   // added will be inserted into *already_seen.  If include_source_code_info is
   // true then include the source code information in the FileDescriptorProtos.
   // If include_json_name is true, populate the json_name field of
   // FieldDescriptorProto for all fields.
   static void GetTransitiveDependencies(
       const FileDescriptor* file,
       bool include_json_name,
       bool include_source_code_info,
-      std::set<const FileDescriptor*>* already_seen,
+      set<const FileDescriptor*>* already_seen,
       RepeatedPtrField<FileDescriptorProto>* output);
 
   // Implements the --print_free_field_numbers. This function prints free field
   // numbers into stdout for the message and it's nested message types in
   // post-order, i.e. nested types first. Printed range are left-right
   // inclusive, i.e. [a, b].
   //
   // Groups:
   // For historical reasons, groups are considered to share the same
   // field number space with the parent message, thus it will not print free
@@ skipping 13 matching lines @@
   // Version info set with SetVersionInfo().
   string version_info_;
 
   // Registered generators.
   struct GeneratorInfo {
     string flag_name;
     string option_flag_name;
     CodeGenerator* generator;
     string help_text;
   };
-  typedef std::map<string, GeneratorInfo> GeneratorMap;
+  typedef map<string, GeneratorInfo> GeneratorMap;
   GeneratorMap generators_by_flag_name_;
   GeneratorMap generators_by_option_name_;
   // A map from generator names to the parameters specified using the option
   // flag. For example, if the user invokes the compiler with:
   //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
   // Then there will be an entry ("--foo_out", "enable_bar") in this map.
-  std::map<string, string> generator_parameters_;
-  // Similar to generator_parameters_, but stores the parameters for plugins.
-  std::map<string, string> plugin_parameters_;
+  map<string, string> generator_parameters_;
 
   // See AllowPlugins().  If this is empty, plugins aren't allowed.
   string plugin_prefix_;
 
   // Maps specific plugin names to files.  When executing a plugin, this map
   // is searched first to find the plugin executable.  If not found here, the
   // PATH (or other OS-specific search strategy) is searched.
-  std::map<string, string> plugins_;
+  map<string, string> plugins_;
 
   // Stuff parsed from command line.
   enum Mode {
     MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
     MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
     MODE_DECODE,   // --decode:  read binary from stdin, write text to stdout.
     MODE_PRINT,    // Print mode: print info of the given .proto files and exit.
   };
 
   Mode mode_;
 
   enum PrintMode {
     PRINT_NONE,               // Not in MODE_PRINT
     PRINT_FREE_FIELDS,        // --print_free_fields
   };
 
   PrintMode print_mode_;
 
   enum ErrorFormat {
     ERROR_FORMAT_GCC,   // GCC error output format (default).
     ERROR_FORMAT_MSVS   // Visual Studio output (--error_format=msvs).
   };
 
   ErrorFormat error_format_;
 
-  std::vector<std::pair<string, string> >
-      proto_path_;                   // Search path for proto files.
-  std::vector<string> input_files_;  // Names of the input proto files.
-
-  // Names of proto files which are allowed to be imported. Used by build
-  // systems to enforce depend-on-what-you-import.
-  std::set<string> direct_dependencies_;
-  bool direct_dependencies_explicitly_set_;
+  vector<pair<string, string> > proto_path_;  // Search path for proto files.
+  vector<string> input_files_;                // Names of the input proto files.
 
   // output_directives_ lists all the files we are supposed to output and what
   // generator to use for each.
   struct OutputDirective {
     string name;                // E.g. "--foo_out"
     CodeGenerator* generator;   // NULL for plugins
     string parameter;
     string output_location;
   };
-  std::vector<OutputDirective> output_directives_;
+  vector<OutputDirective> output_directives_;
 
   // When using --encode or --decode, this names the type we are encoding or
   // decoding.  (Empty string indicates --decode_raw.)
   string codec_type_;
 
   // If --descriptor_set_out was given, this is the filename to which the
   // FileDescriptorSet should be written.  Otherwise, empty.
   string descriptor_set_name_;
 
   // If --dependency_out was given, this is the path to the file where the
@@ skipping 16 matching lines @@
   bool inputs_are_proto_path_relative_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
 };
 
 }  // namespace compiler
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__