// independent from idl_parser, since this code is not needed for most clients
+#include "flatbuffers/code_generators.h"
#include "flatbuffers/flatbuffers.h"
#include "flatbuffers/idl.h"
#include "flatbuffers/util.h"
-#include "flatbuffers/code_generators.h"
-
#include "src/compiler/cpp_generator.h"
#include "src/compiler/go_generator.h"
+#include "src/compiler/java_generator.h"
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4512) // C4512: 'class' : assignment operator could
+// not be generated
+#endif
namespace flatbuffers {
public:
enum Streaming { kNone, kClient, kServer, kBiDi };
- FlatBufMethod(const RPCCall *method)
- : method_(method) {
+ FlatBufMethod(const RPCCall *method) : method_(method) {
streaming_ = kNone;
auto val = method_->attributes.Lookup("streaming");
if (val) {
}
}
+ grpc::string GetLeadingComments(const grpc::string) const { return ""; }
+
+ grpc::string GetTrailingComments(const grpc::string) const { return ""; }
+
+ std::vector<grpc::string> GetAllComments() const {
+ return method_->doc_comment;
+ }
+
std::string name() const { return method_->name; }
std::string GRPCType(const StructDef &sd) const {
- return "flatbuffers::BufferRef<" + sd.name + ">";
+ return "flatbuffers::grpc::Message<" + sd.name + ">";
}
- std::string input_type_name() const {
- return GRPCType(*method_->request);
- }
- std::string output_type_name() const {
- return GRPCType(*method_->response);
- }
+ std::string get_input_type_name() const { return (*method_->request).name; }
- std::string input_name() const {
- return (*method_->request).name;
+ std::string get_output_type_name() const { return (*method_->response).name; }
+
+ bool get_module_and_message_path_input(grpc::string * /*str*/,
+ grpc::string /*generator_file_name*/,
+ bool /*generate_in_pb2_grpc*/,
+ grpc::string /*import_prefix*/) const {
+ return true;
}
- std::string output_name() const {
- return (*method_->response).name;
+ bool get_module_and_message_path_output(
+ grpc::string * /*str*/, grpc::string /*generator_file_name*/,
+ bool /*generate_in_pb2_grpc*/, grpc::string /*import_prefix*/) const {
+ return true;
}
+ std::string input_type_name() const { return GRPCType(*method_->request); }
+
+ std::string output_type_name() const { return GRPCType(*method_->response); }
+
bool NoStreaming() const { return streaming_ == kNone; }
- bool ClientOnlyStreaming() const { return streaming_ == kClient; }
- bool ServerOnlyStreaming() const { return streaming_ == kServer; }
+
+ bool ClientStreaming() const { return streaming_ == kClient; }
+
+ bool ServerStreaming() const { return streaming_ == kServer; }
+
bool BidiStreaming() const { return streaming_ == kBiDi; }
private:
public:
FlatBufService(const ServiceDef *service) : service_(service) {}
+ grpc::string GetLeadingComments(const grpc::string) const { return ""; }
+
+ grpc::string GetTrailingComments(const grpc::string) const { return ""; }
+
+ std::vector<grpc::string> GetAllComments() const {
+ return service_->doc_comment;
+ }
+
std::string name() const { return service_->name; }
int method_count() const {
return static_cast<int>(service_->calls.vec.size());
- };
+ }
std::unique_ptr<const grpc_generator::Method> method(int i) const {
return std::unique_ptr<const grpc_generator::Method>(
- new FlatBufMethod(service_->calls.vec[i]));
- };
+ new FlatBufMethod(service_->calls.vec[i]));
+ }
private:
const ServiceDef *service_;
class FlatBufPrinter : public grpc_generator::Printer {
public:
- FlatBufPrinter(std::string *str)
- : str_(str), escape_char_('$'), indent_(0) {}
+ FlatBufPrinter(std::string *str) : str_(str), escape_char_('$'), indent_(0) {}
void Print(const std::map<std::string, std::string> &vars,
const char *string_template) {
}
void Print(const char *s) {
+ if (s == nullptr || *s == '\0') { return; }
// Add this string, but for each part separated by \n, add indentation.
for (;;) {
// Current indentation.
str_->insert(str_->end(), indent_ * 2, ' ');
// See if this contains more than one line.
- const char * lf = strchr(s, '\n');
+ const char *lf = strchr(s, '\n');
if (lf) {
(*str_) += std::string(s, lf + 1);
s = lf + 1;
}
void Indent() { indent_++; }
- void Outdent() { indent_--; assert(indent_ >= 0); }
+
+ void Outdent() {
+ indent_--;
+ FLATBUFFERS_ASSERT(indent_ >= 0);
+ }
private:
std::string *str_;
class FlatBufFile : public grpc_generator::File {
public:
- FlatBufFile(const Parser &parser, const std::string &file_name)
- : parser_(parser), file_name_(file_name) {}
+ enum Language { kLanguageGo, kLanguageCpp, kLanguageJava };
+
+ FlatBufFile(const Parser &parser, const std::string &file_name,
+ Language language)
+ : parser_(parser), file_name_(file_name), language_(language) {}
+
FlatBufFile &operator=(const FlatBufFile &);
+ grpc::string GetLeadingComments(const grpc::string) const { return ""; }
+
+ grpc::string GetTrailingComments(const grpc::string) const { return ""; }
+
+ std::vector<grpc::string> GetAllComments() const {
+ return std::vector<grpc::string>();
+ }
+
std::string filename() const { return file_name_; }
+
std::string filename_without_ext() const {
return StripExtension(file_name_);
}
std::string message_header_ext() const { return "_generated.h"; }
+
std::string service_header_ext() const { return ".grpc.fb.h"; }
std::string package() const {
- return parser_.namespaces_.back()->GetFullyQualifiedName("");
+ return parser_.current_namespace_->GetFullyQualifiedName("");
}
std::vector<std::string> package_parts() const {
- return parser_.namespaces_.back()->components;
+ return parser_.current_namespace_->components;
}
std::string additional_headers() const {
- return "#include \"flatbuffers/grpc.h\"\n";
- }
-
- std::string additional_imports() const {
- return "import \"github.com/google/flatbuffers/go\"";
+ switch (language_) {
+ case kLanguageCpp: {
+ return "#include \"flatbuffers/grpc.h\"\n";
+ }
+ case kLanguageGo: {
+ return "import \"github.com/google/flatbuffers/go\"";
+ }
+ case kLanguageJava: {
+ return "import com.google.flatbuffers.grpc.FlatbuffersUtils;";
+ }
+ }
+ return "";
}
int service_count() const {
return static_cast<int>(parser_.services_.vec.size());
- };
+ }
std::unique_ptr<const grpc_generator::Service> service(int i) const {
- return std::unique_ptr<const grpc_generator::Service> (
- new FlatBufService(parser_.services_.vec[i]));
+ return std::unique_ptr<const grpc_generator::Service>(
+ new FlatBufService(parser_.services_.vec[i]));
}
- std::unique_ptr<grpc_generator::Printer> CreatePrinter(std::string *str) const {
- return std::unique_ptr<grpc_generator::Printer>(
- new FlatBufPrinter(str));
+ std::unique_ptr<grpc_generator::Printer> CreatePrinter(
+ std::string *str) const {
+ return std::unique_ptr<grpc_generator::Printer>(new FlatBufPrinter(str));
}
private:
const Parser &parser_;
const std::string &file_name_;
+ const Language language_;
};
class GoGRPCGenerator : public flatbuffers::BaseGenerator {
public:
GoGRPCGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
- : BaseGenerator(parser, path, file_name, "", "" /*Unused*/),
- parser_(parser), path_(path), file_name_(file_name) {}
+ : BaseGenerator(parser, path, file_name, "", "" /*Unused*/),
+ parser_(parser),
+ path_(path),
+ file_name_(file_name) {}
bool generate() {
- FlatBufFile file(parser_, file_name_);
+ FlatBufFile file(parser_, file_name_, FlatBufFile::kLanguageGo);
grpc_go_generator::Parameters p;
p.custom_method_io_type = "flatbuffers.Builder";
for (int i = 0; i < file.service_count(); i++) {
auto service = file.service(i);
const Definition *def = parser_.services_.vec[i];
p.package_name = LastNamespacePart(*(def->defined_namespace));
- std::string output = grpc_go_generator::GenerateServiceSource(&file, service.get(), &p);
- std::string filename = NamespaceDir(*def->defined_namespace) + def->name + "_grpc.go";
- if (!flatbuffers::SaveFile(filename.c_str(), output, false))
- return false;
+ p.service_prefix =
+ def->defined_namespace->GetFullyQualifiedName(""); // file.package();
+ std::string output =
+ grpc_go_generator::GenerateServiceSource(&file, service.get(), &p);
+ std::string filename =
+ NamespaceDir(*def->defined_namespace) + def->name + "_grpc.go";
+ if (!flatbuffers::SaveFile(filename.c_str(), output, false)) return false;
}
return true;
}
const std::string &path_, &file_name_;
};
-bool GenerateGoGRPC(const Parser &parser,
- const std::string &path,
+bool GenerateGoGRPC(const Parser &parser, const std::string &path,
const std::string &file_name) {
int nservices = 0;
- for (auto it = parser.services_.vec.begin();
- it != parser.services_.vec.end(); ++it) {
+ for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end();
+ ++it) {
if (!(*it)->generated) nservices++;
}
if (!nservices) return true;
return GoGRPCGenerator(parser, path, file_name).generate();
}
-bool GenerateCppGRPC(const Parser &parser,
- const std::string &/*path*/,
- const std::string &file_name) {
-
+bool GenerateCppGRPC(const Parser &parser, const std::string &path,
+ const std::string &file_name) {
int nservices = 0;
- for (auto it = parser.services_.vec.begin();
- it != parser.services_.vec.end(); ++it) {
+ for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end();
+ ++it) {
if (!(*it)->generated) nservices++;
}
if (!nservices) return true;
// TODO(wvo): make the other parameters in this struct configurable.
generator_parameters.use_system_headers = true;
- FlatBufFile fbfile(parser, file_name);
+ FlatBufFile fbfile(parser, file_name, FlatBufFile::kLanguageCpp);
std::string header_code =
grpc_cpp_generator::GetHeaderPrologue(&fbfile, generator_parameters) +
grpc_cpp_generator::GetSourceServices(&fbfile, generator_parameters) +
grpc_cpp_generator::GetSourceEpilogue(&fbfile, generator_parameters);
- return flatbuffers::SaveFile((file_name + ".grpc.fb.h").c_str(),
+ return flatbuffers::SaveFile((path + file_name + ".grpc.fb.h").c_str(),
header_code, false) &&
- flatbuffers::SaveFile((file_name + ".grpc.fb.cc").c_str(),
+ flatbuffers::SaveFile((path + file_name + ".grpc.fb.cc").c_str(),
source_code, false);
}
+class JavaGRPCGenerator : public flatbuffers::BaseGenerator {
+ public:
+ JavaGRPCGenerator(const Parser &parser, const std::string &path,
+ const std::string &file_name)
+ : BaseGenerator(parser, path, file_name, "", "." /*separator*/) {}
+
+ bool generate() {
+ FlatBufFile file(parser_, file_name_, FlatBufFile::kLanguageJava);
+ grpc_java_generator::Parameters p;
+ for (int i = 0; i < file.service_count(); i++) {
+ auto service = file.service(i);
+ const Definition *def = parser_.services_.vec[i];
+ p.package_name =
+ def->defined_namespace->GetFullyQualifiedName(""); // file.package();
+ std::string output =
+ grpc_java_generator::GenerateServiceSource(&file, service.get(), &p);
+ std::string filename =
+ NamespaceDir(*def->defined_namespace) + def->name + "Grpc.java";
+ if (!flatbuffers::SaveFile(filename.c_str(), output, false)) return false;
+ }
+ return true;
+ }
+};
+
+bool GenerateJavaGRPC(const Parser &parser, const std::string &path,
+ const std::string &file_name) {
+ int nservices = 0;
+ for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end();
+ ++it) {
+ if (!(*it)->generated) nservices++;
+ }
+ if (!nservices) return true;
+ return JavaGRPCGenerator(parser, path, file_name).generate();
+}
+
} // namespace flatbuffers
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
projects / platform / upstream / flatbuffers.git / blobdiff