diff options
34 files changed, 318 insertions, 184 deletions
@@ -152,6 +152,10 @@ $(error Invalid CONFIG value '$(CONFIG)') endif +# Detect if we can use C++11 +CXX11_CHECK_CMD = $(CXX) -std=c++11 -o /dev/null -c test/build/c++11.cc +HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false) + # The HOST compiler settings are used to compile the protoc plugins. # In most cases, you won't have to change anything, but if you are # cross-compiling, you can override these variables from GNU make's @@ -167,7 +171,12 @@ DEFINES += $(DEFINES_$(CONFIG)) INSTALL_PREFIX=\"$(prefix)\" LDFLAGS += $(LDFLAGS_$(CONFIG)) CFLAGS += -std=c89 -pedantic +ifeq ($(HAS_CXX11),true) CXXFLAGS += -std=c++11 +else +CXXFLAGS += -std=c++0x +DEFINES += GRPC_OLD_CXX +endif CPPFLAGS += -g -fPIC -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter LDFLAGS += -g -fPIC @@ -897,7 +906,11 @@ third_party/protobuf/configure: $(LIBDIR)/$(CONFIG)/protobuf/libprotobuf.a: third_party/protobuf/configure $(E) "[MAKE] Building protobuf" +ifeq ($(HAVE_CXX11),true) $(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-DLANG_CXX11 -std=c++11" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static) +else + $(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-std=c++0x" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static) +endif $(Q)$(MAKE) -C third_party/protobuf clean $(Q)$(MAKE) -C third_party/protobuf $(Q)mkdir -p $(LIBDIR)/$(CONFIG)/protobuf diff --git a/examples/pubsub/publisher_test.cc b/examples/pubsub/publisher_test.cc index 4539557a35..c988b4802e 100644 --- a/examples/pubsub/publisher_test.cc +++ b/examples/pubsub/publisher_test.cc @@ -61,28 +61,28 @@ class PublisherServiceImpl : public tech::pubsub::PublisherService::Service { public: Status CreateTopic(::grpc::ServerContext* context, const ::tech::pubsub::Topic* request, - ::tech::pubsub::Topic* response) override { + ::tech::pubsub::Topic* response) GRPC_OVERRIDE { EXPECT_EQ(request->name(), kTopic); return Status::OK; } Status Publish(ServerContext* context, const ::tech::pubsub::PublishRequest* request, - ::proto2::Empty* response) override { + ::proto2::Empty* response) GRPC_OVERRIDE { EXPECT_EQ(request->message().data(), kMessageData); return Status::OK; } Status GetTopic(ServerContext* context, const ::tech::pubsub::GetTopicRequest* request, - ::tech::pubsub::Topic* response) override { + ::tech::pubsub::Topic* response) GRPC_OVERRIDE { EXPECT_EQ(request->topic(), kTopic); return Status::OK; } - Status ListTopics(ServerContext* context, - const ::tech::pubsub::ListTopicsRequest* request, - ::tech::pubsub::ListTopicsResponse* response) override { + Status ListTopics( + ServerContext* context, const ::tech::pubsub::ListTopicsRequest* request, + ::tech::pubsub::ListTopicsResponse* response) GRPC_OVERRIDE { std::ostringstream ss; ss << "cloud.googleapis.com/project in (/projects/" << kProjectId << ")"; EXPECT_EQ(request->query(), ss.str()); @@ -92,7 +92,7 @@ class PublisherServiceImpl : public tech::pubsub::PublisherService::Service { Status DeleteTopic(ServerContext* context, const ::tech::pubsub::DeleteTopicRequest* request, - ::proto2::Empty* response) override { + ::proto2::Empty* response) GRPC_OVERRIDE { EXPECT_EQ(request->topic(), kTopic); return Status::OK; } @@ -102,7 +102,7 @@ class PublisherServiceImpl : public tech::pubsub::PublisherService::Service { class PublisherTest : public ::testing::Test { protected: // Setup a server and a client for PublisherService. - void SetUp() override { + void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); server_address_ << "localhost:" << port; ServerBuilder builder; @@ -116,7 +116,7 @@ class PublisherTest : public ::testing::Test { publisher_.reset(new grpc::examples::pubsub::Publisher(channel_)); } - void TearDown() override { + void TearDown() GRPC_OVERRIDE { server_->Shutdown(); publisher_->Shutdown(); } diff --git a/examples/pubsub/subscriber_test.cc b/examples/pubsub/subscriber_test.cc index c634aa4f82..4ff125f4b3 100644 --- a/examples/pubsub/subscriber_test.cc +++ b/examples/pubsub/subscriber_test.cc @@ -57,9 +57,9 @@ const char kData[] = "Message data"; class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service { public: - Status CreateSubscription(ServerContext* context, - const tech::pubsub::Subscription* request, - tech::pubsub::Subscription* response) override { + Status CreateSubscription( + ServerContext* context, const tech::pubsub::Subscription* request, + tech::pubsub::Subscription* response) GRPC_OVERRIDE { EXPECT_EQ(request->topic(), kTopic); EXPECT_EQ(request->name(), kSubscriptionName); return Status::OK; @@ -67,7 +67,7 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service { Status GetSubscription(ServerContext* context, const tech::pubsub::GetSubscriptionRequest* request, - tech::pubsub::Subscription* response) override { + tech::pubsub::Subscription* response) GRPC_OVERRIDE { EXPECT_EQ(request->subscription(), kSubscriptionName); response->set_topic(kTopic); return Status::OK; @@ -76,14 +76,13 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service { Status DeleteSubscription( ServerContext* context, const tech::pubsub::DeleteSubscriptionRequest* request, - proto2::Empty* response) override { + proto2::Empty* response) GRPC_OVERRIDE { EXPECT_EQ(request->subscription(), kSubscriptionName); return Status::OK; } - Status Pull(ServerContext* context, - const tech::pubsub::PullRequest* request, - tech::pubsub::PullResponse* response) override { + Status Pull(ServerContext* context, const tech::pubsub::PullRequest* request, + tech::pubsub::PullResponse* response) GRPC_OVERRIDE { EXPECT_EQ(request->subscription(), kSubscriptionName); response->set_ack_id("1"); response->mutable_pubsub_event()->mutable_message()->set_data(kData); @@ -92,7 +91,7 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service { Status Acknowledge(ServerContext* context, const tech::pubsub::AcknowledgeRequest* request, - proto2::Empty* response) override { + proto2::Empty* response) GRPC_OVERRIDE { return Status::OK; } @@ -101,7 +100,7 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service { class SubscriberTest : public ::testing::Test { protected: // Setup a server and a client for SubscriberService. - void SetUp() override { + void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); server_address_ << "localhost:" << port; ServerBuilder builder; @@ -115,7 +114,7 @@ class SubscriberTest : public ::testing::Test { subscriber_.reset(new grpc::examples::pubsub::Subscriber(channel_)); } - void TearDown() override { + void TearDown() GRPC_OVERRIDE { server_->Shutdown(); subscriber_->Shutdown(); } diff --git a/include/grpc++/async_unary_call.h b/include/grpc++/async_unary_call.h index b4a654c4a9..ccd0806b28 100644 --- a/include/grpc++/async_unary_call.h +++ b/include/grpc++/async_unary_call.h @@ -45,7 +45,7 @@ namespace grpc { template <class R> -class ClientAsyncResponseReader final { +class ClientAsyncResponseReader GRPC_FINAL { public: ClientAsyncResponseReader(ChannelInterface* channel, CompletionQueue* cq, const RpcMethod& method, ClientContext* context, @@ -79,7 +79,7 @@ class ClientAsyncResponseReader final { private: - ClientContext* context_ = nullptr; + ClientContext* context_; Call call_; CallOpBuffer init_buf_; CallOpBuffer meta_buf_; @@ -87,7 +87,8 @@ class ClientAsyncResponseReader final { }; template <class W> -class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface { +class ServerAsyncResponseWriter GRPC_FINAL + : public ServerAsyncStreamingInterface { public: explicit ServerAsyncResponseWriter(ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} @@ -127,7 +128,7 @@ class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface { } private: - void BindCall(Call* call) override { call_ = *call; } + void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } Call call_; ServerContext* ctx_; diff --git a/include/grpc++/client_context.h b/include/grpc++/client_context.h index 1e7e6bfad7..c5a213e848 100644 --- a/include/grpc++/client_context.h +++ b/include/grpc++/client_context.h @@ -139,7 +139,7 @@ class ClientContext { return authority_; } - bool initial_metadata_received_ = false; + bool initial_metadata_received_; grpc_call *call_; grpc_completion_queue *cq_; gpr_timespec absolute_deadline_; diff --git a/include/grpc++/config.h b/include/grpc++/config.h index 2dced12e37..323ea28632 100644 --- a/include/grpc++/config.h +++ b/include/grpc++/config.h @@ -36,6 +36,14 @@ #include <string> +#ifdef GRPC_OLD_CXX +#define GRPC_FINAL +#define GRPC_OVERRIDE +#else +#define GRPC_FINAL final +#define GRPC_OVERRIDE override +#endif + namespace grpc { typedef std::string string; diff --git a/include/grpc++/credentials.h b/include/grpc++/credentials.h index 5cbcca3aa5..b75755d5bc 100644 --- a/include/grpc++/credentials.h +++ b/include/grpc++/credentials.h @@ -47,7 +47,7 @@ namespace grpc { // to creating an instance using CredentialsFactory, and passing it down // during channel construction. -class Credentials final { +class Credentials GRPC_FINAL { public: ~Credentials(); diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h index 341710f7a2..92ad0c71b7 100644 --- a/include/grpc++/impl/call.h +++ b/include/grpc++/impl/call.h @@ -35,6 +35,7 @@ #define __GRPCPP_CALL_H__ #include <grpc/grpc.h> +#include <grpc++/config.h> #include <grpc++/status.h> #include <grpc++/completion_queue.h> @@ -56,7 +57,7 @@ class Call; class CallOpBuffer : public CompletionQueueTag { public: - CallOpBuffer() : return_tag_(this) {} + CallOpBuffer(); ~CallOpBuffer(); void Reset(void *next_return_tag); @@ -80,40 +81,40 @@ class CallOpBuffer : public CompletionQueueTag { void FillOps(grpc_op *ops, size_t *nops); // Called by completion queue just prior to returning from Next() or Pluck() - bool FinalizeResult(void **tag, bool *status) override; + bool FinalizeResult(void **tag, bool *status) GRPC_OVERRIDE; - bool got_message = false; + bool got_message; private: - void *return_tag_ = nullptr; + void *return_tag_; // Send initial metadata - bool send_initial_metadata_ = false; - size_t initial_metadata_count_ = 0; - grpc_metadata *initial_metadata_ = nullptr; + bool send_initial_metadata_; + size_t initial_metadata_count_; + grpc_metadata *initial_metadata_; // Recv initial metadta - std::multimap<grpc::string, grpc::string> *recv_initial_metadata_ = nullptr; - grpc_metadata_array recv_initial_metadata_arr_ = {0, 0, nullptr}; + std::multimap<grpc::string, grpc::string> *recv_initial_metadata_; + grpc_metadata_array recv_initial_metadata_arr_; // Send message - const google::protobuf::Message *send_message_ = nullptr; - grpc_byte_buffer *send_message_buf_ = nullptr; + const google::protobuf::Message *send_message_; + grpc_byte_buffer *send_message_buf_; // Recv message - google::protobuf::Message *recv_message_ = nullptr; - grpc_byte_buffer *recv_message_buf_ = nullptr; + google::protobuf::Message *recv_message_; + grpc_byte_buffer *recv_message_buf_; // Client send close - bool client_send_close_ = false; + bool client_send_close_; // Client recv status - std::multimap<grpc::string, grpc::string> *recv_trailing_metadata_ = nullptr; - Status *recv_status_ = nullptr; - grpc_metadata_array recv_trailing_metadata_arr_ = {0, 0, nullptr}; - grpc_status_code status_code_ = GRPC_STATUS_OK; - char *status_details_ = nullptr; - size_t status_details_capacity_ = 0; + std::multimap<grpc::string, grpc::string> *recv_trailing_metadata_; + Status *recv_status_; + grpc_metadata_array recv_trailing_metadata_arr_; + grpc_status_code status_code_; + char *status_details_; + size_t status_details_capacity_; // Server send status - const Status *send_status_ = nullptr; - size_t trailing_metadata_count_ = 0; - grpc_metadata *trailing_metadata_ = nullptr; + const Status *send_status_; + size_t trailing_metadata_count_; + grpc_metadata *trailing_metadata_; int cancelled_buf_; - bool *recv_closed_ = nullptr; + bool *recv_closed_; }; // Channel and Server implement this to allow them to hook performing ops @@ -124,7 +125,7 @@ class CallHook { }; // Straightforward wrapping of the C call object -class Call final { +class Call GRPC_FINAL { public: /* call is owned by the caller */ Call(grpc_call *call, CallHook *call_hook_, CompletionQueue *cq); diff --git a/include/grpc++/impl/rpc_service_method.h b/include/grpc++/impl/rpc_service_method.h index ffd5c34ef6..a8794bcd76 100644 --- a/include/grpc++/impl/rpc_service_method.h +++ b/include/grpc++/impl/rpc_service_method.h @@ -77,7 +77,7 @@ class RpcMethodHandler : public MethodHandler { ServiceType* service) : func_(func), service_(service) {} - Status RunHandler(const HandlerParameter& param) final { + Status RunHandler(const HandlerParameter& param) GRPC_FINAL { // Invoke application function, cast proto messages to their actual types. return func_(service_, param.server_context, dynamic_cast<const RequestType*>(param.request), @@ -102,7 +102,7 @@ class ClientStreamingHandler : public MethodHandler { ServiceType* service) : func_(func), service_(service) {} - Status RunHandler(const HandlerParameter& param) final { + Status RunHandler(const HandlerParameter& param) GRPC_FINAL { ServerReader<RequestType> reader(param.call, param.server_context); return func_(service_, param.server_context, &reader, dynamic_cast<ResponseType*>(param.response)); @@ -124,7 +124,7 @@ class ServerStreamingHandler : public MethodHandler { ServiceType* service) : func_(func), service_(service) {} - Status RunHandler(const HandlerParameter& param) final { + Status RunHandler(const HandlerParameter& param) GRPC_FINAL { ServerWriter<ResponseType> writer(param.call, param.server_context); return func_(service_, param.server_context, dynamic_cast<const RequestType*>(param.request), &writer); @@ -147,7 +147,7 @@ class BidiStreamingHandler : public MethodHandler { ServiceType* service) : func_(func), service_(service) {} - Status RunHandler(const HandlerParameter& param) final { + Status RunHandler(const HandlerParameter& param) GRPC_FINAL { ServerReaderWriter<ResponseType, RequestType> stream(param.call, param.server_context); return func_(service_, param.server_context, &stream); diff --git a/include/grpc++/impl/service_type.h b/include/grpc++/impl/service_type.h index cafa2696ab..e54c3c24e1 100644 --- a/include/grpc++/impl/service_type.h +++ b/include/grpc++/impl/service_type.h @@ -79,7 +79,11 @@ class AsynchronousService { AsynchronousService(CompletionQueue* cq, const char** method_names, size_t method_count) - : cq_(cq), method_names_(method_names), method_count_(method_count) {} + : cq_(cq), + dispatch_impl_(nullptr), + method_names_(method_names), + method_count_(method_count), + request_args_(nullptr) {} ~AsynchronousService() { delete[] request_args_; } @@ -116,10 +120,10 @@ class AsynchronousService { private: friend class Server; CompletionQueue* const cq_; - DispatchImpl* dispatch_impl_ = nullptr; + DispatchImpl* dispatch_impl_; const char** const method_names_; size_t method_count_; - void** request_args_ = nullptr; + void** request_args_; }; } // namespace grpc diff --git a/include/grpc++/server.h b/include/grpc++/server.h index 429c0ff3cf..46c4a62235 100644 --- a/include/grpc++/server.h +++ b/include/grpc++/server.h @@ -61,8 +61,8 @@ class ServerCredentials; class ThreadPoolInterface; // Currently it only supports handling rpcs in a single thread. -class Server final : private CallHook, - private AsynchronousService::DispatchImpl { +class Server GRPC_FINAL : private CallHook, + private AsynchronousService::DispatchImpl { public: ~Server(); @@ -97,7 +97,7 @@ class Server final : private CallHook, void RunRpc(); void ScheduleCallback(); - void PerformOpsOnCall(CallOpBuffer* ops, Call* call) override; + void PerformOpsOnCall(CallOpBuffer* ops, Call* call) GRPC_OVERRIDE; // DispatchImpl void RequestAsyncCall(void* registered_method, ServerContext* context, diff --git a/include/grpc++/server_builder.h b/include/grpc++/server_builder.h index 4545c413d2..b672eb3e6a 100644 --- a/include/grpc++/server_builder.h +++ b/include/grpc++/server_builder.h @@ -83,7 +83,7 @@ class ServerBuilder { std::vector<AsynchronousService*> async_services_; std::vector<grpc::string> ports_; std::shared_ptr<ServerCredentials> creds_; - ThreadPoolInterface* thread_pool_ = nullptr; + ThreadPoolInterface* thread_pool_; }; } // namespace grpc diff --git a/include/grpc++/server_context.h b/include/grpc++/server_context.h index d327d8b41e..6db767f05a 100644 --- a/include/grpc++/server_context.h +++ b/include/grpc++/server_context.h @@ -66,7 +66,7 @@ class CompletionQueue; class Server; // Interface of server side rpc context. -class ServerContext final { +class ServerContext GRPC_FINAL { public: ServerContext(); // for async calls ~ServerContext(); @@ -108,12 +108,12 @@ class ServerContext final { ServerContext(gpr_timespec deadline, grpc_metadata* metadata, size_t metadata_count); - CompletionOp* completion_op_ = nullptr; + CompletionOp* completion_op_; std::chrono::system_clock::time_point deadline_; - grpc_call* call_ = nullptr; - CompletionQueue* cq_ = nullptr; - bool sent_initial_metadata_ = false; + grpc_call* call_; + CompletionQueue* cq_; + bool sent_initial_metadata_; std::multimap<grpc::string, grpc::string> client_metadata_; std::multimap<grpc::string, grpc::string> initial_metadata_; std::multimap<grpc::string, grpc::string> trailing_metadata_; diff --git a/include/grpc++/server_credentials.h b/include/grpc++/server_credentials.h index 5c6787a077..8af41597ac 100644 --- a/include/grpc++/server_credentials.h +++ b/include/grpc++/server_credentials.h @@ -44,7 +44,7 @@ struct grpc_server_credentials; namespace grpc { // grpc_server_credentials wrapper class. -class ServerCredentials final { +class ServerCredentials GRPC_FINAL { public: ~ServerCredentials(); diff --git a/include/grpc++/stream.h b/include/grpc++/stream.h index cd95ff7c92..8bcc75bce3 100644 --- a/include/grpc++/stream.h +++ b/include/grpc++/stream.h @@ -83,8 +83,8 @@ class WriterInterface { }; template <class R> -class ClientReader final : public ClientStreamingInterface, - public ReaderInterface<R> { +class ClientReader GRPC_FINAL : public ClientStreamingInterface, + public ReaderInterface<R> { public: // Blocking create a stream and write the first request out. ClientReader(ChannelInterface* channel, const RpcMethod& method, @@ -111,7 +111,7 @@ class ClientReader final : public ClientStreamingInterface, GPR_ASSERT(cq_.Pluck(&buf)); } - virtual bool Read(R* msg) override { + virtual bool Read(R* msg) GRPC_OVERRIDE { CallOpBuffer buf; if (!context_->initial_metadata_received_) { buf.AddRecvInitialMetadata(context_); @@ -121,7 +121,7 @@ class ClientReader final : public ClientStreamingInterface, return cq_.Pluck(&buf) && buf.got_message; } - virtual Status Finish() override { + virtual Status Finish() GRPC_OVERRIDE { CallOpBuffer buf; Status status; buf.AddClientRecvStatus(context_, &status); @@ -137,8 +137,8 @@ class ClientReader final : public ClientStreamingInterface, }; template <class W> -class ClientWriter final : public ClientStreamingInterface, - public WriterInterface<W> { +class ClientWriter GRPC_FINAL : public ClientStreamingInterface, + public WriterInterface<W> { public: // Blocking create a stream. ClientWriter(ChannelInterface* channel, const RpcMethod& method, @@ -152,7 +152,7 @@ class ClientWriter final : public ClientStreamingInterface, cq_.Pluck(&buf); } - virtual bool Write(const W& msg) override { + virtual bool Write(const W& msg) GRPC_OVERRIDE { CallOpBuffer buf; buf.AddSendMessage(msg); call_.PerformOps(&buf); @@ -167,7 +167,7 @@ class ClientWriter final : public ClientStreamingInterface, } // Read the final response and wait for the final status. - virtual Status Finish() override { + virtual Status Finish() GRPC_OVERRIDE { CallOpBuffer buf; Status status; buf.AddRecvMessage(response_); @@ -186,9 +186,9 @@ class ClientWriter final : public ClientStreamingInterface, // Client-side interface for bi-directional streaming. template <class W, class R> -class ClientReaderWriter final : public ClientStreamingInterface, - public WriterInterface<W>, - public ReaderInterface<R> { +class ClientReaderWriter GRPC_FINAL : public ClientStreamingInterface, + public WriterInterface<W>, + public ReaderInterface<R> { public: // Blocking create a stream. ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method, @@ -213,7 +213,7 @@ class ClientReaderWriter final : public ClientStreamingInterface, GPR_ASSERT(cq_.Pluck(&buf)); } - virtual bool Read(R* msg) override { + virtual bool Read(R* msg) GRPC_OVERRIDE { CallOpBuffer buf; if (!context_->initial_metadata_received_) { buf.AddRecvInitialMetadata(context_); @@ -223,7 +223,7 @@ class ClientReaderWriter final : public ClientStreamingInterface, return cq_.Pluck(&buf) && buf.got_message; } - virtual bool Write(const W& msg) override { + virtual bool Write(const W& msg) GRPC_OVERRIDE { CallOpBuffer buf; buf.AddSendMessage(msg); call_.PerformOps(&buf); @@ -237,7 +237,7 @@ class ClientReaderWriter final : public ClientStreamingInterface, return cq_.Pluck(&buf); } - virtual Status Finish() override { + virtual Status Finish() GRPC_OVERRIDE { CallOpBuffer buf; Status status; buf.AddClientRecvStatus(context_, &status); @@ -253,7 +253,7 @@ class ClientReaderWriter final : public ClientStreamingInterface, }; template <class R> -class ServerReader final : public ReaderInterface<R> { +class ServerReader GRPC_FINAL : public ReaderInterface<R> { public: ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} @@ -267,7 +267,7 @@ class ServerReader final : public ReaderInterface<R> { call_->cq()->Pluck(&buf); } - virtual bool Read(R* msg) override { + virtual bool Read(R* msg) GRPC_OVERRIDE { CallOpBuffer buf; buf.AddRecvMessage(msg); call_->PerformOps(&buf); @@ -280,7 +280,7 @@ class ServerReader final : public ReaderInterface<R> { }; template <class W> -class ServerWriter final : public WriterInterface<W> { +class ServerWriter GRPC_FINAL : public WriterInterface<W> { public: ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} @@ -294,7 +294,7 @@ class ServerWriter final : public WriterInterface<W> { call_->cq()->Pluck(&buf); } - virtual bool Write(const W& msg) override { + virtual bool Write(const W& msg) GRPC_OVERRIDE { CallOpBuffer buf; if (!ctx_->sent_initial_metadata_) { buf.AddSendInitialMetadata(&ctx_->initial_metadata_); @@ -312,8 +312,8 @@ class ServerWriter final : public WriterInterface<W> { // Server-side interface for bi-directional streaming. template <class W, class R> -class ServerReaderWriter final : public WriterInterface<W>, - public ReaderInterface<R> { +class ServerReaderWriter GRPC_FINAL : public WriterInterface<W>, + public ReaderInterface<R> { public: ServerReaderWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} @@ -327,14 +327,14 @@ class ServerReaderWriter final : public WriterInterface<W>, call_->cq()->Pluck(&buf); } - virtual bool Read(R* msg) override { + virtual bool Read(R* msg) GRPC_OVERRIDE { CallOpBuffer buf; buf.AddRecvMessage(msg); call_->PerformOps(&buf); return call_->cq()->Pluck(&buf) && buf.got_message; } - virtual bool Write(const W& msg) override { + virtual bool Write(const W& msg) GRPC_OVERRIDE { CallOpBuffer buf; if (!ctx_->sent_initial_metadata_) { buf.AddSendInitialMetadata(&ctx_->initial_metadata_); @@ -380,8 +380,8 @@ class AsyncWriterInterface { }; template <class R> -class ClientAsyncReader final : public ClientAsyncStreamingInterface, - public AsyncReaderInterface<R> { +class ClientAsyncReader GRPC_FINAL : public ClientAsyncStreamingInterface, + public AsyncReaderInterface<R> { public: // Create a stream and write the first request out. ClientAsyncReader(ChannelInterface* channel, CompletionQueue* cq, @@ -395,7 +395,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface, call_.PerformOps(&init_buf_); } - void ReadInitialMetadata(void* tag) override { + void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { GPR_ASSERT(!context_->initial_metadata_received_); meta_buf_.Reset(tag); @@ -403,7 +403,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface, call_.PerformOps(&meta_buf_); } - void Read(R* msg, void* tag) override { + void Read(R* msg, void* tag) GRPC_OVERRIDE { read_buf_.Reset(tag); if (!context_->initial_metadata_received_) { read_buf_.AddRecvInitialMetadata(context_); @@ -412,7 +412,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface, call_.PerformOps(&read_buf_); } - void Finish(Status* status, void* tag) override { + void Finish(Status* status, void* tag) GRPC_OVERRIDE { finish_buf_.Reset(tag); if (!context_->initial_metadata_received_) { finish_buf_.AddRecvInitialMetadata(context_); @@ -422,7 +422,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface, } private: - ClientContext* context_ = nullptr; + ClientContext* context_; Call call_; CallOpBuffer init_buf_; CallOpBuffer meta_buf_; @@ -431,8 +431,8 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface, }; template <class W> -class ClientAsyncWriter final : public ClientAsyncStreamingInterface, - public AsyncWriterInterface<W> { +class ClientAsyncWriter GRPC_FINAL : public ClientAsyncStreamingInterface, + public AsyncWriterInterface<W> { public: ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq, const RpcMethod& method, ClientContext* context, @@ -445,7 +445,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&init_buf_); } - void ReadInitialMetadata(void* tag) override { + void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { GPR_ASSERT(!context_->initial_metadata_received_); meta_buf_.Reset(tag); @@ -453,7 +453,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&meta_buf_); } - void Write(const W& msg, void* tag) override { + void Write(const W& msg, void* tag) GRPC_OVERRIDE { write_buf_.Reset(tag); write_buf_.AddSendMessage(msg); call_.PerformOps(&write_buf_); @@ -465,7 +465,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&writes_done_buf_); } - void Finish(Status* status, void* tag) override { + void Finish(Status* status, void* tag) GRPC_OVERRIDE { finish_buf_.Reset(tag); if (!context_->initial_metadata_received_) { finish_buf_.AddRecvInitialMetadata(context_); @@ -476,7 +476,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface, } private: - ClientContext* context_ = nullptr; + ClientContext* context_; google::protobuf::Message* const response_; Call call_; CallOpBuffer init_buf_; @@ -488,9 +488,9 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface, // Client-side interface for bi-directional streaming. template <class W, class R> -class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, - public AsyncWriterInterface<W>, - public AsyncReaderInterface<R> { +class ClientAsyncReaderWriter GRPC_FINAL : public ClientAsyncStreamingInterface, + public AsyncWriterInterface<W>, + public AsyncReaderInterface<R> { public: ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq, const RpcMethod& method, ClientContext* context, @@ -501,7 +501,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&init_buf_); } - void ReadInitialMetadata(void* tag) override { + void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { GPR_ASSERT(!context_->initial_metadata_received_); meta_buf_.Reset(tag); @@ -509,7 +509,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&meta_buf_); } - void Read(R* msg, void* tag) override { + void Read(R* msg, void* tag) GRPC_OVERRIDE { read_buf_.Reset(tag); if (!context_->initial_metadata_received_) { read_buf_.AddRecvInitialMetadata(context_); @@ -518,7 +518,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&read_buf_); } - void Write(const W& msg, void* tag) override { + void Write(const W& msg, void* tag) GRPC_OVERRIDE { write_buf_.Reset(tag); write_buf_.AddSendMessage(msg); call_.PerformOps(&write_buf_); @@ -530,7 +530,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, call_.PerformOps(&writes_done_buf_); } - void Finish(Status* status, void* tag) override { + void Finish(Status* status, void* tag) GRPC_OVERRIDE { finish_buf_.Reset(tag); if (!context_->initial_metadata_received_) { finish_buf_.AddRecvInitialMetadata(context_); @@ -540,7 +540,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, } private: - ClientContext* context_ = nullptr; + ClientContext* context_; Call call_; CallOpBuffer init_buf_; CallOpBuffer meta_buf_; @@ -551,13 +551,13 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface, }; template <class W, class R> -class ServerAsyncReader : public ServerAsyncStreamingInterface, - public AsyncReaderInterface<R> { +class ServerAsyncReader GRPC_FINAL : public ServerAsyncStreamingInterface, + public AsyncReaderInterface<R> { public: explicit ServerAsyncReader(ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} - void SendInitialMetadata(void* tag) override { + void SendInitialMetadata(void* tag) GRPC_OVERRIDE { GPR_ASSERT(!ctx_->sent_initial_metadata_); meta_buf_.Reset(tag); @@ -566,7 +566,7 @@ class ServerAsyncReader : public ServerAsyncStreamingInterface, call_.PerformOps(&meta_buf_); } - void Read(R* msg, void* tag) override { + void Read(R* msg, void* tag) GRPC_OVERRIDE { read_buf_.Reset(tag); read_buf_.AddRecvMessage(msg); call_.PerformOps(&read_buf_); @@ -598,7 +598,7 @@ class ServerAsyncReader : public ServerAsyncStreamingInterface, } private: - void BindCall(Call* call) override { call_ = *call; } + void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } Call call_; ServerContext* ctx_; @@ -608,13 +608,13 @@ class ServerAsyncReader : public ServerAsyncStreamingInterface, }; template <class W> -class ServerAsyncWriter : public ServerAsyncStreamingInterface, - public AsyncWriterInterface<W> { +class ServerAsyncWriter GRPC_FINAL : public ServerAsyncStreamingInterface, + public AsyncWriterInterface<W> { public: explicit ServerAsyncWriter(ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} - void SendInitialMetadata(void* tag) override { + void SendInitialMetadata(void* tag) GRPC_OVERRIDE { GPR_ASSERT(!ctx_->sent_initial_metadata_); meta_buf_.Reset(tag); @@ -623,7 +623,7 @@ class ServerAsyncWriter : public ServerAsyncStreamingInterface, call_.PerformOps(&meta_buf_); } - void Write(const W& msg, void* tag) override { + void Write(const W& msg, void* tag) GRPC_OVERRIDE { write_buf_.Reset(tag); if (!ctx_->sent_initial_metadata_) { write_buf_.AddSendInitialMetadata(&ctx_->initial_metadata_); @@ -644,7 +644,7 @@ class ServerAsyncWriter : public ServerAsyncStreamingInterface, } private: - void BindCall(Call* call) override { call_ = *call; } + void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } Call call_; ServerContext* ctx_; @@ -655,14 +655,14 @@ class ServerAsyncWriter : public ServerAsyncStreamingInterface, // Server-side interface for bi-directional streaming. template <class W, class R> -class ServerAsyncReaderWriter : public ServerAsyncStreamingInterface, - public AsyncWriterInterface<W>, - public AsyncReaderInterface<R> { +class ServerAsyncReaderWriter GRPC_FINAL : public ServerAsyncStreamingInterface, + public AsyncWriterInterface<W>, + public AsyncReaderInterface<R> { public: explicit ServerAsyncReaderWriter(ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} - void SendInitialMetadata(void* tag) override { + void SendInitialMetadata(void* tag) GRPC_OVERRIDE { GPR_ASSERT(!ctx_->sent_initial_metadata_); meta_buf_.Reset(tag); @@ -671,13 +671,13 @@ class ServerAsyncReaderWriter : public ServerAsyncStreamingInterface, call_.PerformOps(&meta_buf_); } - virtual void Read(R* msg, void* tag) override { + virtual void Read(R* msg, void* tag) GRPC_OVERRIDE { read_buf_.Reset(tag); read_buf_.AddRecvMessage(msg); call_.PerformOps(&read_buf_); } - virtual void Write(const W& msg, void* tag) override { + virtual void Write(const W& msg, void* tag) GRPC_OVERRIDE { write_buf_.Reset(tag); if (!ctx_->sent_initial_metadata_) { write_buf_.AddSendInitialMetadata(&ctx_->initial_metadata_); @@ -698,7 +698,7 @@ class ServerAsyncReaderWriter : public ServerAsyncStreamingInterface, } private: - void BindCall(Call* call) override { call_ = *call; } + void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } Call call_; ServerContext* ctx_; diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc index 891032343b..088fc6bc13 100644 --- a/src/compiler/cpp_generator.cc +++ b/src/compiler/cpp_generator.cc @@ -300,13 +300,13 @@ void PrintHeaderService(google::protobuf::io::Printer *printer, (*vars)["Service"] = service->name(); printer->Print(*vars, - "class $Service$ final {\n" + "class $Service$ GRPC_FINAL {\n" " public:\n"); printer->Indent(); // Client side printer->Print( - "class Stub final : public ::grpc::InternalStub {\n" + "class Stub GRPC_FINAL : public ::grpc::InternalStub {\n" " public:\n"); printer->Indent(); for (int i = 0; i < service->method_count(); ++i) { @@ -331,7 +331,7 @@ void PrintHeaderService(google::protobuf::io::Printer *printer, for (int i = 0; i < service->method_count(); ++i) { PrintHeaderServerMethodSync(printer, service->method(i), vars); } - printer->Print("::grpc::RpcService* service() override final;\n"); + printer->Print("::grpc::RpcService* service() GRPC_OVERRIDE GRPC_FINAL;\n"); printer->Outdent(); printer->Print( " private:\n" @@ -340,7 +340,7 @@ void PrintHeaderService(google::protobuf::io::Printer *printer, // Server side - Asynchronous printer->Print( - "class AsyncService final : public ::grpc::AsynchronousService {\n" + "class AsyncService GRPC_FINAL : public ::grpc::AsynchronousService {\n" " public:\n"); printer->Indent(); (*vars)["MethodCount"] = as_string(service->method_count()); diff --git a/src/compiler/python_generator.cc b/src/compiler/python_generator.cc index a93b08c5ce..490c518399 100644 --- a/src/compiler/python_generator.cc +++ b/src/compiler/python_generator.cc @@ -216,7 +216,8 @@ bool GetModuleAndMessagePath(const Descriptor* type, path_iter != message_path.rend(); ++path_iter) { message_type += (*path_iter)->name() + "."; } - message_type.pop_back(); + // no pop_back prior to C++11 + message_type.resize(message_type.size() - 1); *out = make_pair(module, message_type); return true; } diff --git a/src/compiler/python_plugin.cc b/src/compiler/python_plugin.cc index ed1e0494fb..0dd2c5b834 100644 --- a/src/compiler/python_plugin.cc +++ b/src/compiler/python_plugin.cc @@ -56,12 +56,10 @@ using std::strlen; class PythonGrpcGenerator : public CodeGenerator { public: PythonGrpcGenerator() {} - ~PythonGrpcGenerator() override {} + ~PythonGrpcGenerator() {} - bool Generate(const FileDescriptor* file, - const string& parameter, - GeneratorContext* context, - string* error) const override { + bool Generate(const FileDescriptor* file, const string& parameter, + GeneratorContext* context, string* error) const { // Get output file name. string file_name; static const int proto_suffix_length = strlen(".proto"); diff --git a/src/compiler/ruby_plugin.cc b/src/compiler/ruby_plugin.cc index 6580e5ab5b..4a6e9f7a5d 100644 --- a/src/compiler/ruby_plugin.cc +++ b/src/compiler/ruby_plugin.cc @@ -50,12 +50,12 @@ class RubyGrpcGenerator : public google::protobuf::compiler::CodeGenerator { public: RubyGrpcGenerator() {} - ~RubyGrpcGenerator() override {} + ~RubyGrpcGenerator() {} bool Generate(const google::protobuf::FileDescriptor *file, const std::string ¶meter, google::protobuf::compiler::GeneratorContext *context, - std::string *error) const override { + std::string *error) const { std::string code = grpc_ruby_generator::GetServices(file); if (code.size() == 0) { return true; // don't generate a file if there are no services diff --git a/src/cpp/client/channel.h b/src/cpp/client/channel.h index 06f5a8ffdf..e3edcf73a5 100644 --- a/src/cpp/client/channel.h +++ b/src/cpp/client/channel.h @@ -49,17 +49,17 @@ class CompletionQueue; class Credentials; class StreamContextInterface; -class Channel final : public ChannelInterface { +class Channel GRPC_FINAL : public ChannelInterface { public: Channel(const grpc::string &target, const ChannelArguments &args); Channel(const grpc::string &target, const std::unique_ptr<Credentials> &creds, const ChannelArguments &args); - ~Channel() override; + ~Channel() GRPC_OVERRIDE; virtual Call CreateCall(const RpcMethod &method, ClientContext *context, - CompletionQueue *cq) override; - virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) override; + CompletionQueue *cq) GRPC_OVERRIDE; + virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) GRPC_OVERRIDE; private: const grpc::string target_; diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc index 80cbdd93ac..9f99f7bcd5 100644 --- a/src/cpp/client/client_context.cc +++ b/src/cpp/client/client_context.cc @@ -41,7 +41,10 @@ using std::chrono::system_clock; namespace grpc { ClientContext::ClientContext() - : call_(nullptr), cq_(nullptr), absolute_deadline_(gpr_inf_future) {} + : initial_metadata_received_(false), + call_(nullptr), + cq_(nullptr), + absolute_deadline_(gpr_inf_future) {} ClientContext::~ClientContext() { if (call_) { diff --git a/src/cpp/common/call.cc b/src/cpp/common/call.cc index e6a20a252d..f3a691114d 100644 --- a/src/cpp/common/call.cc +++ b/src/cpp/common/call.cc @@ -41,6 +41,30 @@ namespace grpc { +CallOpBuffer::CallOpBuffer() + : return_tag_(this), + send_initial_metadata_(false), + initial_metadata_count_(0), + initial_metadata_(nullptr), + recv_initial_metadata_(nullptr), + recv_initial_metadata_arr_{0, 0, nullptr}, + send_message_(nullptr), + send_message_buf_(nullptr), + recv_message_(nullptr), + recv_message_buf_(nullptr), + client_send_close_(false), + recv_trailing_metadata_(nullptr), + recv_status_(nullptr), + recv_trailing_metadata_arr_{0, 0, nullptr}, + status_code_(GRPC_STATUS_OK), + status_details_(nullptr), + status_details_capacity_(0), + send_status_(nullptr), + trailing_metadata_count_(0), + trailing_metadata_(nullptr), + cancelled_buf_(0), + recv_closed_(nullptr) {} + void CallOpBuffer::Reset(void* next_return_tag) { return_tag_ = next_return_tag; diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index 178fa1a716..97bf0f1a6e 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -49,11 +49,12 @@ namespace grpc { -class Server::SyncRequest final : public CompletionQueueTag { +class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { public: SyncRequest(RpcServiceMethod* method, void* tag) : method_(method), tag_(tag), + in_flight_(false), has_request_payload_(method->method_type() == RpcMethod::NORMAL_RPC || method->method_type() == RpcMethod::SERVER_STREAMING), @@ -85,14 +86,14 @@ class Server::SyncRequest final : public CompletionQueueTag { this)); } - bool FinalizeResult(void** tag, bool* status) override { + bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { if (!*status) { grpc_completion_queue_destroy(cq_); } return true; } - class CallData final { + class CallData GRPC_FINAL { public: explicit CallData(Server* server, SyncRequest* mrd) : cq_(mrd->cq_), @@ -159,7 +160,7 @@ class Server::SyncRequest final : public CompletionQueueTag { private: RpcServiceMethod* const method_; void* const tag_; - bool in_flight_ = false; + bool in_flight_; const bool has_request_payload_; const bool has_response_payload_; grpc_call* call_; @@ -294,7 +295,7 @@ void Server::PerformOpsOnCall(CallOpBuffer* buf, Call* call) { grpc_call_start_batch(call->call(), ops, nops, buf)); } -class Server::AsyncRequest final : public CompletionQueueTag { +class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag { public: AsyncRequest(Server* server, void* registered_method, ServerContext* ctx, ::google::protobuf::Message* request, @@ -305,7 +306,9 @@ class Server::AsyncRequest final : public CompletionQueueTag { stream_(stream), cq_(cq), ctx_(ctx), - server_(server) { + server_(server), + call_(nullptr), + payload_(nullptr) { memset(&array_, 0, sizeof(array_)); grpc_server_request_registered_call( server->server_, registered_method, &call_, &deadline_, &array_, @@ -319,7 +322,7 @@ class Server::AsyncRequest final : public CompletionQueueTag { grpc_metadata_array_destroy(&array_); } - bool FinalizeResult(void** tag, bool* status) override { + bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { *tag = tag_; if (*status && request_) { if (payload_) { @@ -354,10 +357,10 @@ class Server::AsyncRequest final : public CompletionQueueTag { CompletionQueue* const cq_; ServerContext* const ctx_; Server* const server_; - grpc_call* call_ = nullptr; + grpc_call* call_; gpr_timespec deadline_; grpc_metadata_array array_; - grpc_byte_buffer* payload_ = nullptr; + grpc_byte_buffer* payload_; }; void Server::RequestAsyncCall(void* registered_method, ServerContext* context, diff --git a/src/cpp/server/server_builder.cc b/src/cpp/server/server_builder.cc index 3c2093c363..ae60f3d8b6 100644 --- a/src/cpp/server/server_builder.cc +++ b/src/cpp/server/server_builder.cc @@ -41,7 +41,7 @@ namespace grpc { -ServerBuilder::ServerBuilder() {} +ServerBuilder::ServerBuilder() : thread_pool_(nullptr) {} void ServerBuilder::RegisterService(SynchronousService* service) { services_.push_back(service->service()); diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc index 1aa18bcac5..bb3c2d1405 100644 --- a/src/cpp/server/server_context.cc +++ b/src/cpp/server/server_context.cc @@ -44,10 +44,13 @@ namespace grpc { // CompletionOp -class ServerContext::CompletionOp final : public CallOpBuffer { +class ServerContext::CompletionOp GRPC_FINAL : public CallOpBuffer { public: - CompletionOp(); - bool FinalizeResult(void** tag, bool* status) override; + // initial refs: one in the server context, one in the cq + CompletionOp() : refs_(2), finalized_(false), cancelled_(false) { + AddServerRecvClose(&cancelled_); + } + bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool CheckCancelled(CompletionQueue* cq); @@ -55,13 +58,11 @@ class ServerContext::CompletionOp final : public CallOpBuffer { private: std::mutex mu_; - int refs_ = 2; // initial refs: one in the server context, one in the cq - bool finalized_ = false; - bool cancelled_ = false; + int refs_; + bool finalized_; + bool cancelled_; }; -ServerContext::CompletionOp::CompletionOp() { AddServerRecvClose(&cancelled_); } - void ServerContext::CompletionOp::Unref() { std::unique_lock<std::mutex> lock(mu_); if (--refs_ == 0) { @@ -90,11 +91,19 @@ bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) { // ServerContext body -ServerContext::ServerContext() {} +ServerContext::ServerContext() + : completion_op_(nullptr), + call_(nullptr), + cq_(nullptr), + sent_initial_metadata_(false) {} ServerContext::ServerContext(gpr_timespec deadline, grpc_metadata* metadata, size_t metadata_count) - : deadline_(Timespec2Timepoint(deadline)) { + : completion_op_(nullptr), + deadline_(Timespec2Timepoint(deadline)), + call_(nullptr), + cq_(nullptr), + sent_initial_metadata_(false) { for (size_t i = 0; i < metadata_count; i++) { client_metadata_.insert(std::make_pair( grpc::string(metadata[i].key), diff --git a/src/cpp/server/thread_pool.cc b/src/cpp/server/thread_pool.cc index fa11ddd04c..5dc9bcf916 100644 --- a/src/cpp/server/thread_pool.cc +++ b/src/cpp/server/thread_pool.cc @@ -35,7 +35,7 @@ namespace grpc { -ThreadPool::ThreadPool(int num_threads) { +ThreadPool::ThreadPool(int num_threads) : shutdown_(false) { for (int i = 0; i < num_threads; i++) { threads_.push_back(std::thread([this]() { for (;;) { diff --git a/src/cpp/server/thread_pool.h b/src/cpp/server/thread_pool.h index 283618f4b6..9c1df0b15b 100644 --- a/src/cpp/server/thread_pool.h +++ b/src/cpp/server/thread_pool.h @@ -34,6 +34,7 @@ #ifndef __GRPCPP_INTERNAL_SERVER_THREAD_POOL_H__ #define __GRPCPP_INTERNAL_SERVER_THREAD_POOL_H__ +#include <grpc++/config.h> #include <grpc++/thread_pool_interface.h> #include <condition_variable> @@ -44,17 +45,17 @@ namespace grpc { -class ThreadPool final : public ThreadPoolInterface { +class ThreadPool GRPC_FINAL : public ThreadPoolInterface { public: explicit ThreadPool(int num_threads); ~ThreadPool(); - void ScheduleCallback(const std::function<void()> &callback) override; + void ScheduleCallback(const std::function<void()> &callback) GRPC_OVERRIDE; private: std::mutex mu_; std::condition_variable cv_; - bool shutdown_ = false; + bool shutdown_; std::queue<std::function<void()>> callbacks_; std::vector<std::thread> threads_; }; diff --git a/templates/Makefile.template b/templates/Makefile.template index 0984a6d008..84c5402e2f 100644 --- a/templates/Makefile.template +++ b/templates/Makefile.template @@ -169,6 +169,10 @@ $(error Invalid CONFIG value '$(CONFIG)') endif +# Detect if we can use C++11 +CXX11_CHECK_CMD = $(CXX) -std=c++11 -o /dev/null -c test/build/c++11.cc +HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false) + # The HOST compiler settings are used to compile the protoc plugins. # In most cases, you won't have to change anything, but if you are # cross-compiling, you can override these variables from GNU make's @@ -184,7 +188,12 @@ DEFINES += $(DEFINES_$(CONFIG)) INSTALL_PREFIX=\"$(prefix)\" LDFLAGS += $(LDFLAGS_$(CONFIG)) CFLAGS += -std=c89 -pedantic +ifeq ($(HAS_CXX11),true) CXXFLAGS += -std=c++11 +else +CXXFLAGS += -std=c++0x +DEFINES += GRPC_OLD_CXX +endif CPPFLAGS += -g -fPIC -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter LDFLAGS += -g -fPIC @@ -495,7 +504,11 @@ third_party/protobuf/configure: $(LIBDIR)/$(CONFIG)/protobuf/libprotobuf.a: third_party/protobuf/configure $(E) "[MAKE] Building protobuf" +ifeq ($(HAVE_CXX11),true) $(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-DLANG_CXX11 -std=c++11" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static) +else + $(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-std=c++0x" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static) +endif $(Q)$(MAKE) -C third_party/protobuf clean $(Q)$(MAKE) -C third_party/protobuf $(Q)mkdir -p $(LIBDIR)/$(CONFIG)/protobuf diff --git a/test/build/c++11.cc b/test/build/c++11.cc new file mode 100644 index 0000000000..519395f20a --- /dev/null +++ b/test/build/c++11.cc @@ -0,0 +1,52 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * 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. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* This is just a compilation test, to see if we have zlib installed. */ + +#include <stdlib.h> +#include <zlib.h> + +class Base { + public: + virtual void foo() = 0; +}; + +class Foo final : public Base { + public: + void foo() override {} +}; + +int main() { + Foo().foo(); + return 0; +} diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc index 9e25a5308d..5a2762d049 100644 --- a/test/cpp/end2end/async_end2end_test.cc +++ b/test/cpp/end2end/async_end2end_test.cc @@ -81,7 +81,7 @@ class AsyncEnd2endTest : public ::testing::Test { protected: AsyncEnd2endTest() : service_(&srv_cq_) {} - void SetUp() override { + void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); server_address_ << "localhost:" << port; // Setup server @@ -91,7 +91,7 @@ class AsyncEnd2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() override { + void TearDown() GRPC_OVERRIDE { server_->Shutdown(); void* ignored_tag; bool ignored_ok; diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc index 45f12a9e9d..1d5dfc4e34 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -83,7 +83,7 @@ void MaybeEchoDeadline(ServerContext* context, const EchoRequest* request, class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) override { + EchoResponse* response) GRPC_OVERRIDE { response->set_message(request->message()); MaybeEchoDeadline(context, request, response); return Status::OK; @@ -93,7 +93,7 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { Status RequestStream(ServerContext* context, ServerReader<EchoRequest>* reader, - EchoResponse* response) override { + EchoResponse* response) GRPC_OVERRIDE { EchoRequest request; response->set_message(""); while (reader->Read(&request)) { @@ -105,7 +105,7 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { // Return 3 messages. // TODO(yangg) make it generic by adding a parameter into EchoRequest Status ResponseStream(ServerContext* context, const EchoRequest* request, - ServerWriter<EchoResponse>* writer) override { + ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { EchoResponse response; response.set_message(request->message() + "0"); writer->Write(response); @@ -117,9 +117,9 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { return Status::OK; } - Status BidiStream( - ServerContext* context, - ServerReaderWriter<EchoResponse, EchoRequest>* stream) override { + Status BidiStream(ServerContext* context, + ServerReaderWriter<EchoResponse, EchoRequest>* stream) + GRPC_OVERRIDE { EchoRequest request; EchoResponse response; while (stream->Read(&request)) { @@ -135,7 +135,7 @@ class TestServiceImplDupPkg : public ::grpc::cpp::test::util::duplicate::TestService::Service { public: Status Echo(ServerContext* context, const EchoRequest* request, - EchoResponse* response) override { + EchoResponse* response) GRPC_OVERRIDE { response->set_message("no package"); return Status::OK; } @@ -145,7 +145,7 @@ class End2endTest : public ::testing::Test { protected: End2endTest() : thread_pool_(2) {} - void SetUp() override { + void SetUp() GRPC_OVERRIDE { int port = grpc_pick_unused_port_or_die(); server_address_ << "localhost:" << port; // Setup server @@ -157,7 +157,7 @@ class End2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() override { server_->Shutdown(); } + void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void ResetStub() { std::shared_ptr<ChannelInterface> channel = diff --git a/test/cpp/interop/client.cc b/test/cpp/interop/client.cc index acfaa87ec8..f7537c2d7b 100644 --- a/test/cpp/interop/client.cc +++ b/test/cpp/interop/client.cc @@ -38,6 +38,8 @@ #include <string> #include <thread> +#include <unistd.h> + #include <grpc/grpc.h> #include <grpc/support/log.h> #include <gflags/gflags.h> @@ -313,8 +315,7 @@ void DoResponseStreamingWithSlowConsumer() { GPR_ASSERT(response.payload().body() == grpc::string(kResponseMessageSize, '\0')); gpr_log(GPR_INFO, "received message %d", i); - std::this_thread::sleep_for( - std::chrono::milliseconds(kReceiveDelayMilliSeconds)); + usleep(kReceiveDelayMilliSeconds * 1000); ++i; } GPR_ASSERT(kNumResponseMessages == i); diff --git a/test/cpp/interop/server.cc b/test/cpp/interop/server.cc index 263bd8e304..9810ff6622 100644 --- a/test/cpp/interop/server.cc +++ b/test/cpp/interop/server.cc @@ -36,6 +36,7 @@ #include <thread> #include <signal.h> +#include <unistd.h> #include <gflags/gflags.h> #include <grpc/grpc.h> @@ -222,7 +223,7 @@ void RunServer() { std::unique_ptr<Server> server(builder.BuildAndStart()); gpr_log(GPR_INFO, "Server listening on %s", server_address.str().c_str()); while (!got_sigint) { - std::this_thread::sleep_for(std::chrono::seconds(5)); + sleep(5); } } diff --git a/test/cpp/qps/server.cc b/test/cpp/qps/server.cc index 8e136349a1..be27c12b30 100644 --- a/test/cpp/qps/server.cc +++ b/test/cpp/qps/server.cc @@ -36,6 +36,8 @@ #include <sys/signal.h> #include <thread> +#include <unistd.h> + #include <gflags/gflags.h> #include <grpc/support/alloc.h> #include <grpc/support/host_port.h> @@ -97,7 +99,7 @@ static bool SetPayload(PayloadType type, int size, Payload* payload) { namespace { -class TestServiceImpl final : public TestService::Service { +class TestServiceImpl GRPC_FINAL : public TestService::Service { public: Status CollectServerStats(ServerContext* context, const StatsRequest*, ServerStats* response) { @@ -146,7 +148,7 @@ static void RunServer() { grpc_profiler_start("qps_server.prof"); while (!got_sigint) { - std::this_thread::sleep_for(std::chrono::seconds(5)); + sleep(5); } grpc_profiler_stop(); |