The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
317 lines
12 KiB
317 lines
12 KiB
/* |
|
* |
|
* Copyright 2015 gRPC authors. |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
* |
|
*/ |
|
|
|
// Generates Objective C gRPC service interface out of Protobuf IDL. |
|
|
|
#include <memory> |
|
|
|
#include "src/compiler/config.h" |
|
#include "src/compiler/objective_c_generator.h" |
|
#include "src/compiler/objective_c_generator_helpers.h" |
|
|
|
#include <google/protobuf/compiler/objectivec/objectivec_helpers.h> |
|
|
|
using ::google::protobuf::compiler::objectivec:: |
|
IsProtobufLibraryBundledProtoFile; |
|
using ::google::protobuf::compiler::objectivec::ProtobufLibraryFrameworkName; |
|
using ::grpc_objective_c_generator::FrameworkImport; |
|
using ::grpc_objective_c_generator::LocalImport; |
|
using ::grpc_objective_c_generator::PreprocIfElse; |
|
using ::grpc_objective_c_generator::PreprocIfNot; |
|
using ::grpc_objective_c_generator::SystemImport; |
|
|
|
namespace { |
|
|
|
inline ::std::string ImportProtoHeaders( |
|
const grpc::protobuf::FileDescriptor* dep, const char* indent, |
|
const ::std::string& framework, |
|
const ::std::string& pb_runtime_import_prefix) { |
|
::std::string header = grpc_objective_c_generator::MessageHeaderName(dep); |
|
|
|
if (!IsProtobufLibraryBundledProtoFile(dep)) { |
|
if (framework.empty()) { |
|
return indent + LocalImport(header); |
|
} else { |
|
return indent + FrameworkImport(header, framework); |
|
} |
|
} |
|
|
|
::std::string base_name = header; |
|
grpc_generator::StripPrefix(&base_name, "google/protobuf/"); |
|
::std::string file_name = "GPB" + base_name; |
|
// create the import code snippet |
|
::std::string framework_header = |
|
::std::string(ProtobufLibraryFrameworkName) + "/" + file_name; |
|
::std::string local_header = file_name; |
|
if (!pb_runtime_import_prefix.empty()) { |
|
local_header = pb_runtime_import_prefix + "/" + file_name; |
|
} |
|
|
|
static const ::std::string kFrameworkImportsCondition = |
|
"GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS"; |
|
return PreprocIfElse(kFrameworkImportsCondition, |
|
indent + SystemImport(framework_header), |
|
indent + LocalImport(local_header)); |
|
} |
|
|
|
} // namespace |
|
|
|
class ObjectiveCGrpcGenerator : public grpc::protobuf::compiler::CodeGenerator { |
|
public: |
|
ObjectiveCGrpcGenerator() {} |
|
virtual ~ObjectiveCGrpcGenerator() {} |
|
|
|
public: |
|
uint64_t GetSupportedFeatures() const override { |
|
return FEATURE_PROTO3_OPTIONAL; |
|
} |
|
|
|
virtual bool Generate(const grpc::protobuf::FileDescriptor* file, |
|
const ::std::string& parameter, |
|
grpc::protobuf::compiler::GeneratorContext* context, |
|
::std::string* error) const override { |
|
if (file->service_count() == 0) { |
|
// No services. Do nothing. |
|
return true; |
|
} |
|
|
|
bool grpc_local_import = false; |
|
::std::string framework; |
|
::std::string pb_runtime_import_prefix; |
|
::std::string grpc_local_import_prefix; |
|
std::vector<::std::string> params_list = |
|
grpc_generator::tokenize(parameter, ","); |
|
for (auto param_str = params_list.begin(); param_str != params_list.end(); |
|
++param_str) { |
|
std::vector<::std::string> param = |
|
grpc_generator::tokenize(*param_str, "="); |
|
if (param[0] == "generate_for_named_framework") { |
|
if (param.size() != 2) { |
|
*error = |
|
std::string("Format: generate_for_named_framework=<Framework>"); |
|
return false; |
|
} else if (param[1].empty()) { |
|
*error = |
|
std::string("Name of framework cannot be empty for parameter: ") + |
|
param[0]; |
|
return false; |
|
} |
|
framework = param[1]; |
|
} else if (param[0] == "runtime_import_prefix") { |
|
if (param.size() != 2) { |
|
*error = grpc::string("Format: runtime_import_prefix=dir/"); |
|
return false; |
|
} |
|
pb_runtime_import_prefix = param[1]; |
|
grpc_generator::StripSuffix(&pb_runtime_import_prefix, "/"); |
|
} else if (param[0] == "grpc_local_import_prefix") { |
|
grpc_local_import = true; |
|
if (param.size() != 2) { |
|
*error = grpc::string("Format: grpc_local_import_prefix=dir/"); |
|
return false; |
|
} |
|
grpc_local_import_prefix = param[1]; |
|
} |
|
} |
|
|
|
static const ::std::string kNonNullBegin = "NS_ASSUME_NONNULL_BEGIN\n"; |
|
static const ::std::string kNonNullEnd = "NS_ASSUME_NONNULL_END\n"; |
|
static const ::std::string kProtocolOnly = "GPB_GRPC_PROTOCOL_ONLY"; |
|
static const ::std::string kForwardDeclare = |
|
"GPB_GRPC_FORWARD_DECLARE_MESSAGE_PROTO"; |
|
|
|
::std::string file_name = |
|
google::protobuf::compiler::objectivec::FilePath(file); |
|
|
|
grpc_objective_c_generator::Parameters generator_params; |
|
generator_params.no_v1_compatibility = false; |
|
|
|
if (!parameter.empty()) { |
|
std::vector<std::string> parameters_list = |
|
grpc_generator::tokenize(parameter, ","); |
|
for (auto parameter_string = parameters_list.begin(); |
|
parameter_string != parameters_list.end(); parameter_string++) { |
|
std::vector<std::string> param = |
|
grpc_generator::tokenize(*parameter_string, "="); |
|
if (param[0] == "no_v1_compatibility") { |
|
generator_params.no_v1_compatibility = true; |
|
} |
|
} |
|
} |
|
|
|
// Write out a file header. |
|
::std::string file_header = |
|
"// Code generated by gRPC proto compiler. DO NOT EDIT!\n" |
|
"// source: " + |
|
file->name() + "\n\n"; |
|
|
|
{ |
|
// Generate .pbrpc.h |
|
|
|
::std::string imports; |
|
if (framework.empty()) { |
|
imports = LocalImport(file_name + ".pbobjc.h"); |
|
} else { |
|
imports = FrameworkImport(file_name + ".pbobjc.h", framework); |
|
} |
|
|
|
::std::string system_imports; |
|
if (grpc_local_import) { |
|
system_imports = |
|
LocalImport(grpc_local_import_prefix + "ProtoRPC/ProtoService.h"); |
|
if (generator_params.no_v1_compatibility) { |
|
system_imports += |
|
LocalImport(grpc_local_import_prefix + "ProtoRPC/ProtoRPC.h"); |
|
} else { |
|
system_imports += LocalImport(grpc_local_import_prefix + |
|
"ProtoRPC/ProtoRPCLegacy.h"); |
|
system_imports += LocalImport(grpc_local_import_prefix + |
|
"RxLibrary/GRXWriteable.h"); |
|
system_imports += |
|
LocalImport(grpc_local_import_prefix + "RxLibrary/GRXWriter.h"); |
|
} |
|
} else { |
|
system_imports = SystemImport("ProtoRPC/ProtoService.h"); |
|
if (generator_params.no_v1_compatibility) { |
|
system_imports += SystemImport("ProtoRPC/ProtoRPC.h"); |
|
} else { |
|
system_imports += SystemImport("ProtoRPC/ProtoRPCLegacy.h"); |
|
system_imports += SystemImport("RxLibrary/GRXWriteable.h"); |
|
system_imports += SystemImport("RxLibrary/GRXWriter.h"); |
|
} |
|
} |
|
|
|
::std::string forward_declarations = |
|
"@class GRPCUnaryProtoCall;\n" |
|
"@class GRPCStreamingProtoCall;\n" |
|
"@class GRPCCallOptions;\n" |
|
"@protocol GRPCProtoResponseHandler;\n"; |
|
if (!generator_params.no_v1_compatibility) { |
|
forward_declarations += "@class GRPCProtoCall;\n"; |
|
} |
|
forward_declarations += "\n"; |
|
|
|
::std::string class_declarations = |
|
grpc_objective_c_generator::GetAllMessageClasses(file); |
|
|
|
::std::string class_imports; |
|
for (int i = 0; i < file->dependency_count(); i++) { |
|
class_imports += ImportProtoHeaders( |
|
file->dependency(i), " ", framework, pb_runtime_import_prefix); |
|
} |
|
|
|
::std::string ng_protocols; |
|
for (int i = 0; i < file->service_count(); i++) { |
|
const grpc::protobuf::ServiceDescriptor* service = file->service(i); |
|
ng_protocols += grpc_objective_c_generator::GetV2Protocol(service); |
|
} |
|
|
|
::std::string protocols; |
|
for (int i = 0; i < file->service_count(); i++) { |
|
const grpc::protobuf::ServiceDescriptor* service = file->service(i); |
|
protocols += |
|
grpc_objective_c_generator::GetProtocol(service, generator_params); |
|
} |
|
|
|
::std::string interfaces; |
|
for (int i = 0; i < file->service_count(); i++) { |
|
const grpc::protobuf::ServiceDescriptor* service = file->service(i); |
|
interfaces += |
|
grpc_objective_c_generator::GetInterface(service, generator_params); |
|
} |
|
|
|
Write(context, file_name + ".pbrpc.h", |
|
file_header + SystemImport("Foundation/Foundation.h") + "\n" + |
|
PreprocIfNot(kForwardDeclare, imports) + "\n" + |
|
PreprocIfNot(kProtocolOnly, system_imports) + "\n" + |
|
class_declarations + "\n" + |
|
PreprocIfNot(kForwardDeclare, class_imports) + "\n" + |
|
forward_declarations + "\n" + kNonNullBegin + "\n" + |
|
ng_protocols + protocols + "\n" + |
|
PreprocIfNot(kProtocolOnly, interfaces) + "\n" + kNonNullEnd + |
|
"\n"); |
|
} |
|
|
|
{ |
|
// Generate .pbrpc.m |
|
|
|
::std::string imports; |
|
if (framework.empty()) { |
|
imports = LocalImport(file_name + ".pbrpc.h") + |
|
LocalImport(file_name + ".pbobjc.h"); |
|
} else { |
|
imports = FrameworkImport(file_name + ".pbrpc.h", framework) + |
|
FrameworkImport(file_name + ".pbobjc.h", framework); |
|
} |
|
|
|
if (grpc_local_import) { |
|
if (generator_params.no_v1_compatibility) { |
|
imports += |
|
LocalImport(grpc_local_import_prefix + "ProtoRPC/ProtoRPC.h"); |
|
} else { |
|
imports += LocalImport(grpc_local_import_prefix + |
|
"ProtoRPC/ProtoRPCLegacy.h"); |
|
imports += LocalImport(grpc_local_import_prefix + |
|
"RxLibrary/GRXWriter+Immediate.h"); |
|
} |
|
} else { |
|
if (generator_params.no_v1_compatibility) { |
|
imports += SystemImport("ProtoRPC/ProtoRPC.h"); |
|
} else { |
|
imports += SystemImport("ProtoRPC/ProtoRPCLegacy.h"); |
|
imports += SystemImport("RxLibrary/GRXWriter+Immediate.h"); |
|
} |
|
} |
|
|
|
::std::string class_imports; |
|
for (int i = 0; i < file->dependency_count(); i++) { |
|
class_imports += ImportProtoHeaders(file->dependency(i), "", framework, |
|
pb_runtime_import_prefix); |
|
} |
|
|
|
::std::string definitions; |
|
for (int i = 0; i < file->service_count(); i++) { |
|
const grpc::protobuf::ServiceDescriptor* service = file->service(i); |
|
definitions += |
|
grpc_objective_c_generator::GetSource(service, generator_params); |
|
} |
|
|
|
Write(context, file_name + ".pbrpc.m", |
|
file_header + |
|
PreprocIfNot(kProtocolOnly, imports + "\n" + class_imports + |
|
"\n" + definitions)); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
private: |
|
// Write the given code into the given file. |
|
void Write(grpc::protobuf::compiler::GeneratorContext* context, |
|
const ::std::string& filename, const ::std::string& code) const { |
|
std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> output( |
|
context->Open(filename)); |
|
grpc::protobuf::io::CodedOutputStream coded_out(output.get()); |
|
coded_out.WriteRaw(code.data(), code.size()); |
|
} |
|
}; |
|
|
|
int main(int argc, char* argv[]) { |
|
ObjectiveCGrpcGenerator generator; |
|
return grpc::protobuf::compiler::PluginMain(argc, argv, &generator); |
|
}
|
|
|