#include <BnetFileGenerator.h>

Public Member Functions
	BnetFileGenerator (const pb::FileDescriptor *file, const pbcpp::Options &options)

	~BnetFileGenerator ()

void	GenerateHeader (pb::io::Printer *printer)

void	GenerateSource (pb::io::Printer *printer)

Private Member Functions
void	GenerateBuildDescriptors (pb::io::Printer *printer)

void	GenerateNamespaceOpeners (pb::io::Printer *printer)

void	GenerateNamespaceClosers (pb::io::Printer *printer)

	GOOGLE_DISALLOW_EVIL_CONSTRUCTORS (BnetFileGenerator)

Private Attributes
const pb::FileDescriptor *	file_

pb::scoped_array < pb::scoped_ptr < pbcpp::MessageGenerator > >	message_generators_

pb::scoped_array < pb::scoped_ptr < pbcpp::EnumGenerator > >	enum_generators_

pb::scoped_array < pb::scoped_ptr < BnetServiceGenerator > >	service_generators_

pb::scoped_array < pb::scoped_ptr < pbcpp::ExtensionGenerator > >	extension_generators_

std::vector< std::string >	package_parts_

const pbcpp::Options	options_

Constructor & Destructor Documentation

BnetFileGenerator::BnetFileGenerator	(	const pb::FileDescriptor *	file,
		const pbcpp::Options &	options
	)

explicit

  : file_(file),
  message_generators_(
  new pb::scoped_ptr<pbcpp::MessageGenerator>[file->message_type_count()]),
  enum_generators_(
  new pb::scoped_ptr<pbcpp::EnumGenerator>[file->enum_type_count()]),
  service_generators_(
  new pb::scoped_ptr<BnetServiceGenerator>[file->service_count()]),
  extension_generators_(
  new pb::scoped_ptr<pbcpp::ExtensionGenerator>[file->extension_count()]),
  options_(options)
 {
 
  for (int i = 0; i < file->message_type_count(); i++)
  {
  message_generators_[i].reset(
  new pbcpp::MessageGenerator(file->message_type(i), options));
  }
 
  for (int i = 0; i < file->enum_type_count(); i++)
  {
  enum_generators_[i].reset(
  new pbcpp::EnumGenerator(file->enum_type(i), options));
  }
 
  for (int i = 0; i < file->service_count(); i++)
  {
  service_generators_[i].reset(
  new BnetServiceGenerator(file->service(i), options));
  }
 
  for (int i = 0; i < file->extension_count(); i++)
  {
  extension_generators_[i].reset(
  new pbcpp::ExtensionGenerator(file->extension(i), options));
  }
 
  pb::SplitStringUsing(file_->package(), ".", &package_parts_);
 }

Here is the call graph for this function:

BnetFileGenerator::~BnetFileGenerator ( )

93 { }

Member Function Documentation

void BnetFileGenerator::GenerateBuildDescriptors ( pb::io::Printer * printer )

private

 {
  // AddDescriptors() is a file-level procedure which adds the encoded
  // FileDescriptorProto for this .proto file to the global DescriptorPool for
  // generated files (DescriptorPool::generated_pool()). It either runs at
  // static initialization time (by default) or when default_instance() is
  // called for the first time (in LITE_RUNTIME mode with
  // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER flag enabled). This procedure also
  // constructs default instances and registers extensions.
  //
  // Its sibling, AssignDescriptors(), actually pulls the compiled
  // FileDescriptor from the DescriptorPool and uses it to populate all of
  // the global variables which store pointers to the descriptor objects.
  // It also constructs the reflection objects. It is called the first time
  // anyone calls descriptor() or GetReflection() on one of the types defined
  // in the file.
 
  // In optimize_for = LITE_RUNTIME mode, we don't generate AssignDescriptors()
  // and we only use AddDescriptors() to allocate default instances.
  if (pbcpp::HasDescriptorMethods(file_))
  {
  printer->Print(
  "\n"
  "void $assigndescriptorsname$() {\n",
  "assigndescriptorsname", pbcpp::GlobalAssignDescriptorsName(file_->name()));
  printer->Indent();
 
  // Make sure the file has found its way into the pool. If a descriptor
  // is requested *during* static init then AddDescriptors() may not have
  // been called yet, so we call it manually. Note that it's fine if
  // AddDescriptors() is called multiple times.
  printer->Print(
  "$adddescriptorsname$();\n",
  "adddescriptorsname", pbcpp::GlobalAddDescriptorsName(file_->name()));
 
  // Get the file's descriptor from the pool.
  printer->Print(
  "const ::google::protobuf::FileDescriptor* file =\n"
  " ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(\n"
  " \"$filename$\");\n"
  // Note that this GOOGLE_CHECK is necessary to prevent a warning about "file"
  // being unused when compiling an empty .proto file.
  "GOOGLE_CHECK(file != NULL);\n",
  "filename", file_->name());
 
  // Go through all the stuff defined in this file and generated code to
  // assign the global descriptor pointers based on the file descriptor.
  for (int i = 0; i < file_->message_type_count(); i++)
  {
  message_generators_[i]->GenerateDescriptorInitializer(printer, i);
  }
  for (int i = 0; i < file_->enum_type_count(); i++)
  {
  enum_generators_[i]->GenerateDescriptorInitializer(printer, i);
  }
  for (int i = 0; i < file_->service_count(); i++)
  {
  service_generators_[i]->GenerateDescriptorInitializer(printer, i);
  }
 
  printer->Outdent();
  printer->Print(
  "}\n"
  "\n");
 
  // ---------------------------------------------------------------
 
  // protobuf_AssignDescriptorsOnce(): The first time it is called, calls
  // AssignDescriptors(). All later times, waits for the first call to
  // complete and then returns.
  printer->Print(
  "namespace {\n"
  "\n"
  "GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);\n"
  "inline void protobuf_AssignDescriptorsOnce() {\n"
  " ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,\n"
  " &$assigndescriptorsname$);\n"
  "}\n"
  "\n",
  "assigndescriptorsname", pbcpp::GlobalAssignDescriptorsName(file_->name()));
 
  // protobuf_RegisterTypes(): Calls
  // MessageFactory::InternalRegisterGeneratedType() for each message type.
  printer->Print(
  "void protobuf_RegisterTypes(const ::std::string&) {\n"
  " protobuf_AssignDescriptorsOnce();\n");
  printer->Indent();
 
  for (int i = 0; i < file_->message_type_count(); i++)
  {
  message_generators_[i]->GenerateTypeRegistrations(printer);
  }
 
  printer->Outdent();
  printer->Print(
  "}\n"
  "\n"
  "} // namespace\n");
  }
 
  // -----------------------------------------------------------------
 
  // ShutdownFile(): Deletes descriptors, default instances, etc. on shutdown.
  printer->Print(
  "\n"
  "void $shutdownfilename$() {\n",
  "shutdownfilename", pbcpp::GlobalShutdownFileName(file_->name()));
  printer->Indent();
 
  for (int i = 0; i < file_->message_type_count(); i++)
  {
  message_generators_[i]->GenerateShutdownCode(printer);
  }
 
  printer->Outdent();
  printer->Print(
  "}\n\n");
 
  // -----------------------------------------------------------------
 
  // Now generate the AddDescriptors() function.
  pbcpp::PrintHandlingOptionalStaticInitializers(
  file_, printer,
  // With static initializers.
  // Note that we don't need any special synchronization in the following code
  // because it is called at static init time before any threads exist.
  "void $adddescriptorsname$() {\n"
  " static bool already_here = false;\n"
  " if (already_here) return;\n"
  " already_here = true;\n"
  " GOOGLE_PROTOBUF_VERIFY_VERSION;\n"
  "\n",
  // Without.
  "void $adddescriptorsname$_impl() {\n"
  " GOOGLE_PROTOBUF_VERIFY_VERSION;\n"
  "\n",
  // Vars.
  "adddescriptorsname", pbcpp::GlobalAddDescriptorsName(file_->name()));
 
  printer->Indent();
 
  // Call the AddDescriptors() methods for all of our dependencies, to make
  // sure they get added first.
  for (int i = 0; i < file_->dependency_count(); i++)
  {
  const pb::FileDescriptor* dependency = file_->dependency(i);
  // Print the namespace prefix for the dependency.
  std::string add_desc_name = pbcpp::QualifiedFileLevelSymbol(
  dependency->package(), pbcpp::GlobalAddDescriptorsName(dependency->name()));
  // Call its AddDescriptors function.
  printer->Print(
  "$name$();\n",
  "name", add_desc_name);
  }
 
  if (pbcpp::HasDescriptorMethods(file_))
  {
  // Embed the descriptor. We simply serialize the entire FileDescriptorProto
  // and embed it as a string literal, which is parsed and built into real
  // descriptors at initialization time.
  pb::FileDescriptorProto file_proto;
  file_->CopyTo(&file_proto);
  std::string file_data;
  file_proto.SerializeToString(&file_data);
 
  printer->Print(
  "::google::protobuf::DescriptorPool::InternalAddGeneratedFile(");
 
  // Only write 40 bytes per line.
  static const int kBytesPerLine = 40;
  for (int i = 0; i < file_data.size(); i += kBytesPerLine)
  {
  printer->Print("\n \"$data$\"",
  "data",
  pbcpp::EscapeTrigraphs(
  pb::CEscape(file_data.substr(i, kBytesPerLine))));
  }
  printer->Print(
  ", $size$);\n",
  "size", pb::SimpleItoa(file_data.size()));
 
  // Call MessageFactory::InternalRegisterGeneratedFile().
  printer->Print(
  "::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(\n"
  " \"$filename$\", &protobuf_RegisterTypes);\n",
  "filename", file_->name());
  }
 
  // Allocate and initialize default instances. This can't be done lazily
  // since default instances are returned by simple accessors and are used with
  // extensions. Speaking of which, we also register extensions at this time.
  for (int i = 0; i < file_->message_type_count(); i++)
  {
  message_generators_[i]->GenerateDefaultInstanceAllocator(printer);
  }
  for (int i = 0; i < file_->extension_count(); i++)
  {
  extension_generators_[i]->GenerateRegistration(printer);
  }
  for (int i = 0; i < file_->message_type_count(); i++)
  {
  message_generators_[i]->GenerateDefaultInstanceInitializer(printer);
  }
 
  printer->Print(
  "::google::protobuf::internal::OnShutdown(&$shutdownfilename$);\n",
  "shutdownfilename", pbcpp::GlobalShutdownFileName(file_->name()));
 
  printer->Outdent();
  printer->Print(
  "}\n"
  "\n");
 
  pbcpp::PrintHandlingOptionalStaticInitializers(
  file_, printer,
  // With static initializers.
  "// Force AddDescriptors() to be called at static initialization time.\n"
  "struct StaticDescriptorInitializer_$filename$ {\n"
  " StaticDescriptorInitializer_$filename$() {\n"
  " $adddescriptorsname$();\n"
  " }\n"
  "} static_descriptor_initializer_$filename$_;\n",
  // Without.
  "GOOGLE_PROTOBUF_DECLARE_ONCE($adddescriptorsname$_once_);\n"
  "void $adddescriptorsname$() {\n"
  " ::google::protobuf::GoogleOnceInit(&$adddescriptorsname$_once_,\n"
  " &$adddescriptorsname$_impl);\n"
  "}\n",
  // Vars.
  "adddescriptorsname", pbcpp::GlobalAddDescriptorsName(file_->name()),
  "filename", pbcpp::FilenameIdentifier(file_->name()));
 }

Here is the call graph for this function: