Merge pull request #8602 from vjpai/turn_it_to_11

Stop supporting non-C++11 conformant compilers - DO NOT MERGE INTO V1.0.X
pull/8608/head^2
Vijay Pai 9 years ago committed by GitHub
commit b37ace5d27
  1. 27
      BUILD
  2. 27
      CMakeLists.txt
  3. 30
      Makefile
  4. 9
      build.yaml
  5. 88
      doc/cpp-style-guide.md
  6. 2
      include/grpc++/alarm.h
  7. 20
      include/grpc++/channel.h
  8. 12
      include/grpc++/ext/proto_server_reflection_plugin.h
  9. 4
      include/grpc++/generic/async_generic_service.h
  10. 2
      include/grpc++/generic/generic_stub.h
  11. 64
      include/grpc++/impl/codegen/async_stream.h
  12. 9
      include/grpc++/impl/codegen/async_unary_call.h
  13. 14
      include/grpc++/impl/codegen/call.h
  14. 6
      include/grpc++/impl/codegen/client_context.h
  15. 83
      include/grpc++/impl/codegen/config.h
  16. 67
      include/grpc++/impl/codegen/core_codegen.h
  17. 45
      include/grpc++/impl/codegen/impl/sync.h
  18. 10
      include/grpc++/impl/codegen/method_handler_impl.h
  19. 22
      include/grpc++/impl/codegen/proto_utils.h
  20. 2
      include/grpc++/impl/codegen/server_context.h
  21. 10
      include/grpc++/impl/codegen/server_interface.h
  22. 45
      include/grpc++/impl/codegen/sync.h
  23. 49
      include/grpc++/impl/codegen/sync_cxx11.h
  24. 111
      include/grpc++/impl/codegen/sync_no_cxx11.h
  25. 76
      include/grpc++/impl/codegen/sync_stream.h
  26. 4
      include/grpc++/impl/codegen/time.h
  27. 8
      include/grpc++/impl/grpc_library.h
  28. 39
      include/grpc++/impl/sync.h
  29. 45
      include/grpc++/impl/thd.h
  30. 45
      include/grpc++/impl/thd_cxx11.h
  31. 117
      include/grpc++/impl/thd_no_cxx11.h
  32. 2
      include/grpc++/resource_quota.h
  33. 28
      include/grpc++/server.h
  34. 2
      include/grpc++/support/byte_buffer.h
  35. 2
      include/grpc++/support/slice.h
  36. 67
      src/compiler/cpp_generator.cc
  37. 6
      src/cpp/client/channel_cc.cc
  38. 12
      src/cpp/client/client_context.cc
  39. 8
      src/cpp/client/cronet_credentials.cc
  40. 8
      src/cpp/client/insecure_credentials.cc
  41. 14
      src/cpp/client/secure_credentials.h
  42. 2
      src/cpp/common/channel_filter.h
  43. 21
      src/cpp/common/secure_auth_context.h
  44. 4
      src/cpp/ext/proto_server_reflection.h
  45. 18
      src/cpp/server/dynamic_thread_pool.cc
  46. 17
      src/cpp/server/dynamic_thread_pool.h
  47. 7
      src/cpp/server/insecure_server_credentials.cc
  48. 11
      src/cpp/server/secure_server_credentials.h
  49. 32
      src/cpp/server/server_cc.cc
  50. 17
      src/cpp/server/server_context.cc
  51. 29
      src/cpp/thread_manager/thread_manager.cc
  52. 13
      src/cpp/thread_manager/thread_manager.h
  53. 5
      src/cpp/util/time_cc.cc
  54. 52
      test/cpp/codegen/compiler_test_golden
  55. 4
      test/cpp/common/auth_property_iterator_test.cc
  56. 10
      test/cpp/end2end/async_end2end_test.cc
  57. 9
      test/cpp/end2end/client_crash_test_server.cc
  58. 22
      test/cpp/end2end/end2end_test.cc
  59. 20
      test/cpp/end2end/filter_end2end_test.cc
  60. 4
      test/cpp/end2end/generic_end2end_test.cc
  61. 28
      test/cpp/end2end/hybrid_end2end_test.cc
  62. 62
      test/cpp/end2end/mock_test.cc
  63. 2
      test/cpp/end2end/proto_server_reflection_test.cc
  64. 14
      test/cpp/end2end/round_robin_end2end_test.cc
  65. 29
      test/cpp/end2end/server_builder_plugin_test.cc
  66. 11
      test/cpp/end2end/server_crash_test.cc
  67. 6
      test/cpp/end2end/shutdown_test.cc
  68. 10
      test/cpp/end2end/streaming_throughput_test.cc
  69. 12
      test/cpp/end2end/test_service_impl.h
  70. 52
      test/cpp/end2end/thread_stress_test.cc
  71. 5
      test/cpp/interop/stress_test.cc
  72. 2
      test/cpp/qps/client.h
  73. 41
      test/cpp/qps/client_async.cc
  74. 10
      test/cpp/qps/client_sync.cc
  75. 6
      test/cpp/qps/interarrival.h
  76. 20
      test/cpp/qps/qps_worker.cc
  77. 24
      test/cpp/qps/report.h
  78. 22
      test/cpp/qps/server_async.cc
  79. 8
      test/cpp/qps/server_sync.cc
  80. 7
      test/cpp/thread_manager/thread_manager_test.cc
  81. 2
      test/cpp/util/cli_call.h
  82. 6
      test/cpp/util/cli_call_test.cc
  83. 9
      test/cpp/util/grpc_tool_test.cc
  84. 6
      test/cpp/util/metrics_server.h
  85. 4
      test/cpp/util/proto_file_parser.cc
  86. 9
      test/cpp/util/proto_reflection_descriptor_database.h
  87. 26
      test/cpp/util/test_credentials_provider.cc
  88. 9
      tools/doxygen/Doxyfile.c++
  89. 9
      tools/doxygen/Doxyfile.c++.internal
  90. 18
      tools/run_tests/sources_and_headers.json
  91. 9
      vsprojects/vcxproj/grpc++/grpc++.vcxproj
  92. 27
      vsprojects/vcxproj/grpc++/grpc++.vcxproj.filters
  93. 3
      vsprojects/vcxproj/grpc++_test_util/grpc++_test_util.vcxproj
  94. 9
      vsprojects/vcxproj/grpc++_test_util/grpc++_test_util.vcxproj.filters
  95. 9
      vsprojects/vcxproj/grpc++_unsecure/grpc++_unsecure.vcxproj
  96. 27
      vsprojects/vcxproj/grpc++_unsecure/grpc++_unsecure.vcxproj.filters
  97. 3
      vsprojects/vcxproj/test/codegen_test_full/codegen_test_full.vcxproj
  98. 9
      vsprojects/vcxproj/test/codegen_test_full/codegen_test_full.vcxproj.filters
  99. 3
      vsprojects/vcxproj/test/codegen_test_minimal/codegen_test_minimal.vcxproj
  100. 9
      vsprojects/vcxproj/test/codegen_test_minimal/codegen_test_minimal.vcxproj.filters
  101. Some files were not shown because too many files have changed in this diff Show More

27
BUILD

@ -1402,12 +1402,6 @@ cc_library(
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -1455,9 +1449,6 @@ cc_library(
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h", "include/grpc++/impl/codegen/time.h",
"include/grpc/impl/codegen/byte_buffer_reader.h", "include/grpc/impl/codegen/byte_buffer_reader.h",
@ -1554,12 +1545,6 @@ cc_library(
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -1607,9 +1592,6 @@ cc_library(
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h", "include/grpc++/impl/codegen/time.h",
"include/grpc/impl/codegen/byte_buffer_reader.h", "include/grpc/impl/codegen/byte_buffer_reader.h",
@ -1727,12 +1709,6 @@ cc_library(
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -1780,9 +1756,6 @@ cc_library(
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h", "include/grpc++/impl/codegen/time.h",
"include/grpc/impl/codegen/byte_buffer_reader.h", "include/grpc/impl/codegen/byte_buffer_reader.h",

@ -1121,12 +1121,6 @@ foreach(_hdr
include/grpc++/impl/server_builder_plugin.h include/grpc++/impl/server_builder_plugin.h
include/grpc++/impl/server_initializer.h include/grpc++/impl/server_initializer.h
include/grpc++/impl/service_type.h include/grpc++/impl/service_type.h
include/grpc++/impl/sync.h
include/grpc++/impl/sync_cxx11.h
include/grpc++/impl/sync_no_cxx11.h
include/grpc++/impl/thd.h
include/grpc++/impl/thd_cxx11.h
include/grpc++/impl/thd_no_cxx11.h
include/grpc++/resource_quota.h include/grpc++/resource_quota.h
include/grpc++/security/auth_context.h include/grpc++/security/auth_context.h
include/grpc++/security/auth_metadata_processor.h include/grpc++/security/auth_metadata_processor.h
@ -1174,9 +1168,6 @@ foreach(_hdr
include/grpc++/impl/codegen/status_helper.h include/grpc++/impl/codegen/status_helper.h
include/grpc++/impl/codegen/string_ref.h include/grpc++/impl/codegen/string_ref.h
include/grpc++/impl/codegen/stub_options.h include/grpc++/impl/codegen/stub_options.h
include/grpc++/impl/codegen/sync.h
include/grpc++/impl/codegen/sync_cxx11.h
include/grpc++/impl/codegen/sync_no_cxx11.h
include/grpc++/impl/codegen/sync_stream.h include/grpc++/impl/codegen/sync_stream.h
include/grpc++/impl/codegen/time.h include/grpc++/impl/codegen/time.h
include/grpc/impl/codegen/byte_buffer_reader.h include/grpc/impl/codegen/byte_buffer_reader.h
@ -1287,12 +1278,6 @@ foreach(_hdr
include/grpc++/impl/server_builder_plugin.h include/grpc++/impl/server_builder_plugin.h
include/grpc++/impl/server_initializer.h include/grpc++/impl/server_initializer.h
include/grpc++/impl/service_type.h include/grpc++/impl/service_type.h
include/grpc++/impl/sync.h
include/grpc++/impl/sync_cxx11.h
include/grpc++/impl/sync_no_cxx11.h
include/grpc++/impl/thd.h
include/grpc++/impl/thd_cxx11.h
include/grpc++/impl/thd_no_cxx11.h
include/grpc++/resource_quota.h include/grpc++/resource_quota.h
include/grpc++/security/auth_context.h include/grpc++/security/auth_context.h
include/grpc++/security/auth_metadata_processor.h include/grpc++/security/auth_metadata_processor.h
@ -1340,9 +1325,6 @@ foreach(_hdr
include/grpc++/impl/codegen/status_helper.h include/grpc++/impl/codegen/status_helper.h
include/grpc++/impl/codegen/string_ref.h include/grpc++/impl/codegen/string_ref.h
include/grpc++/impl/codegen/stub_options.h include/grpc++/impl/codegen/stub_options.h
include/grpc++/impl/codegen/sync.h
include/grpc++/impl/codegen/sync_cxx11.h
include/grpc++/impl/codegen/sync_no_cxx11.h
include/grpc++/impl/codegen/sync_stream.h include/grpc++/impl/codegen/sync_stream.h
include/grpc++/impl/codegen/time.h include/grpc++/impl/codegen/time.h
include/grpc/impl/codegen/byte_buffer_reader.h include/grpc/impl/codegen/byte_buffer_reader.h
@ -1491,12 +1473,6 @@ foreach(_hdr
include/grpc++/impl/server_builder_plugin.h include/grpc++/impl/server_builder_plugin.h
include/grpc++/impl/server_initializer.h include/grpc++/impl/server_initializer.h
include/grpc++/impl/service_type.h include/grpc++/impl/service_type.h
include/grpc++/impl/sync.h
include/grpc++/impl/sync_cxx11.h
include/grpc++/impl/sync_no_cxx11.h
include/grpc++/impl/thd.h
include/grpc++/impl/thd_cxx11.h
include/grpc++/impl/thd_no_cxx11.h
include/grpc++/resource_quota.h include/grpc++/resource_quota.h
include/grpc++/security/auth_context.h include/grpc++/security/auth_context.h
include/grpc++/security/auth_metadata_processor.h include/grpc++/security/auth_metadata_processor.h
@ -1544,9 +1520,6 @@ foreach(_hdr
include/grpc++/impl/codegen/status_helper.h include/grpc++/impl/codegen/status_helper.h
include/grpc++/impl/codegen/string_ref.h include/grpc++/impl/codegen/string_ref.h
include/grpc++/impl/codegen/stub_options.h include/grpc++/impl/codegen/stub_options.h
include/grpc++/impl/codegen/sync.h
include/grpc++/impl/codegen/sync_cxx11.h
include/grpc++/impl/codegen/sync_no_cxx11.h
include/grpc++/impl/codegen/sync_stream.h include/grpc++/impl/codegen/sync_stream.h
include/grpc++/impl/codegen/time.h include/grpc++/impl/codegen/time.h
include/grpc/impl/codegen/byte_buffer_reader.h include/grpc/impl/codegen/byte_buffer_reader.h

@ -3751,12 +3751,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -3804,9 +3798,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -3946,12 +3937,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -3999,9 +3984,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -4347,9 +4329,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -4480,12 +4459,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -4533,9 +4506,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \

@ -710,12 +710,6 @@ filegroups:
- include/grpc++/impl/server_builder_plugin.h - include/grpc++/impl/server_builder_plugin.h
- include/grpc++/impl/server_initializer.h - include/grpc++/impl/server_initializer.h
- include/grpc++/impl/service_type.h - include/grpc++/impl/service_type.h
- include/grpc++/impl/sync.h
- include/grpc++/impl/sync_cxx11.h
- include/grpc++/impl/sync_no_cxx11.h
- include/grpc++/impl/thd.h
- include/grpc++/impl/thd_cxx11.h
- include/grpc++/impl/thd_no_cxx11.h
- include/grpc++/resource_quota.h - include/grpc++/resource_quota.h
- include/grpc++/security/auth_context.h - include/grpc++/security/auth_context.h
- include/grpc++/security/auth_metadata_processor.h - include/grpc++/security/auth_metadata_processor.h
@ -802,9 +796,6 @@ filegroups:
- include/grpc++/impl/codegen/status_helper.h - include/grpc++/impl/codegen/status_helper.h
- include/grpc++/impl/codegen/string_ref.h - include/grpc++/impl/codegen/string_ref.h
- include/grpc++/impl/codegen/stub_options.h - include/grpc++/impl/codegen/stub_options.h
- include/grpc++/impl/codegen/sync.h
- include/grpc++/impl/codegen/sync_cxx11.h
- include/grpc++/impl/codegen/sync_no_cxx11.h
- include/grpc++/impl/codegen/sync_stream.h - include/grpc++/impl/codegen/sync_stream.h
- include/grpc++/impl/codegen/time.h - include/grpc++/impl/codegen/time.h
uses: uses:

@ -1,91 +1,9 @@
GRPC C++ STYLE GUIDE GRPC C++ STYLE GUIDE
===================== =====================
Background The majority of gRPC's C++ requirements are drawn from the [Google C++ style
---------- guide] (https://google.github.io/styleguide/cppguide.html). Additionally,
as in C, layout rules are defined by clang-format, and all code
Here we document style rules for C++ usage in the gRPC C++ bindings
and tests.
General
-------
- The majority of gRPC's C++ requirements are drawn from the [Google C++ style
guide] (https://google.github.io/styleguide/cppguide.html)
- However, gRPC has some additional requirements to maintain
[portability] (#portability)
- As in C, layout rules are defined by clang-format, and all code
should be passed through clang-format. A (docker-based) script to do should be passed through clang-format. A (docker-based) script to do
so is included in [tools/distrib/clang\_format\_code.sh] so is included in [tools/distrib/clang\_format\_code.sh]
(../tools/distrib/clang_format_code.sh). (../tools/distrib/clang_format_code.sh).
<a name="portability"></a>
Portability Restrictions
-------------------
gRPC supports a large number of compilers, ranging from those that are
missing many key C++11 features to those that have quite detailed
analysis. As a result, gRPC compiles with a high level of warnings and
treat all warnings as errors. gRPC also forbids the use of some common
C++11 constructs. Here are some guidelines, to be extended as needed:
- Do not use range-based for. Expressions of the form
```c
for (auto& i: vec) {
// code
}
```
are not allowed and should be replaced with code such as
```c
for (auto it = vec.begin; it != vec.end(); it++) {
auto& i = *it;
// code
}
```
- Do not use lambda of any kind (no capture, explicit capture, or
default capture). Other C++ functional features such as
`std::function` or `std::bind` are allowed
- Do not use brace-list initializers.
- Do not compare a pointer to `nullptr` . This is because gcc 4.4
does not support `nullptr` directly and gRPC implements a subset of
its features in [include/grpc++/impl/codegen/config.h]
(../include/grpc++/impl/codegen/config.h). Instead, pointers should
be checked for validity using their implicit conversion to `bool`.
In other words, use `if (p)` rather than `if (p != nullptr)`
- Do not initialize global/static pointer variables to `nullptr`. Just let
the compiler implicitly initialize them to `nullptr` (which it will
definitely do). The reason is that `nullptr` is an actual object in
our implementation rather than just a constant pointer value, so
static/global constructors will be called in a potentially
undesirable sequence.
- Do not use `final` or `override` as these are not supported by some
compilers. Instead use `GRPC_FINAL` and `GRPC_OVERRIDE` . These
compile down to the traditional C++ forms for compilers that support
them but are just elided if the compiler does not support those features.
- In the [include] (../../../tree/master/include/grpc++) and [src]
(../../../tree/master/src/cpp) directory trees, you should also not
use certain STL objects like `std::mutex`, `std::lock_guard`,
`std::unique_lock`, `std::nullptr`, `std::thread` . Instead, use
`grpc::mutex`, `grpc::lock_guard`, etc., which are gRPC
implementations of the prominent features of these objects that are
not always available. You can use the `std` versions of those in [test]
(../../../tree/master/test/cpp)
- Similarly, in the same directories, do not use `std::chrono` unless
it is guarded by `#ifndef GRPC_CXX0X_NO_CHRONO` . For platforms that
lack`std::chrono,` there is a C-language timer called gpr_timespec that can
be used instead.
- `std::unique_ptr` must be used with extreme care in any kind of
collection. For example `vector<std::unique_ptr>` does not work in
gcc 4.4 if the vector is constructed to its full size at
initialization but does work if elements are added to the vector
using functions like `push_back`. `map` and other pair-based
collections do not work with `unique_ptr` under gcc 4.4. The issue
is that many of these collection implementations assume a copy
constructor
to be available.
- Don't use `std::this_thread` . Use `gpr_sleep_until` for sleeping a thread.
- [Some adjacent character combinations cause problems]
(https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C). If declaring a
template against some class relative to the global namespace,
`<::name` will be non-portable. Separate the `<` from the `:` and use `< ::name`.

@ -78,7 +78,7 @@ class Alarm : private GrpcLibraryCodegen {
class AlarmEntry : public CompletionQueueTag { class AlarmEntry : public CompletionQueueTag {
public: public:
AlarmEntry(void* tag) : tag_(tag) {} AlarmEntry(void* tag) : tag_(tag) {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
*tag = tag_; *tag = tag_;
return true; return true;
} }

@ -46,16 +46,16 @@ struct grpc_channel;
namespace grpc { namespace grpc {
/// Channels represent a connection to an endpoint. Created by \a CreateChannel. /// Channels represent a connection to an endpoint. Created by \a CreateChannel.
class Channel GRPC_FINAL : public ChannelInterface, class Channel final : public ChannelInterface,
public CallHook, public CallHook,
public std::enable_shared_from_this<Channel>, public std::enable_shared_from_this<Channel>,
private GrpcLibraryCodegen { private GrpcLibraryCodegen {
public: public:
~Channel(); ~Channel();
/// Get the current channel state. If the channel is in IDLE and /// Get the current channel state. If the channel is in IDLE and
/// \a try_to_connect is set to true, try to connect. /// \a try_to_connect is set to true, try to connect.
grpc_connectivity_state GetState(bool try_to_connect) GRPC_OVERRIDE; grpc_connectivity_state GetState(bool try_to_connect) override;
private: private:
template <class InputMessage, class OutputMessage> template <class InputMessage, class OutputMessage>
@ -69,15 +69,15 @@ class Channel GRPC_FINAL : public ChannelInterface,
Channel(const grpc::string& host, grpc_channel* c_channel); Channel(const grpc::string& host, grpc_channel* c_channel);
Call CreateCall(const RpcMethod& method, ClientContext* context, Call CreateCall(const RpcMethod& method, ClientContext* context,
CompletionQueue* cq) GRPC_OVERRIDE; CompletionQueue* cq) override;
void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) GRPC_OVERRIDE; void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override;
void* RegisterMethod(const char* method) GRPC_OVERRIDE; void* RegisterMethod(const char* method) override;
void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline, CompletionQueue* cq, gpr_timespec deadline, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE; void* tag) override;
bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline) GRPC_OVERRIDE; gpr_timespec deadline) override;
const grpc::string host_; const grpc::string host_;
grpc_channel* const c_channel_; // owned grpc_channel* const c_channel_; // owned

@ -48,12 +48,12 @@ namespace reflection {
class ProtoServerReflectionPlugin : public ::grpc::ServerBuilderPlugin { class ProtoServerReflectionPlugin : public ::grpc::ServerBuilderPlugin {
public: public:
ProtoServerReflectionPlugin(); ProtoServerReflectionPlugin();
::grpc::string name() GRPC_OVERRIDE; ::grpc::string name() override;
void InitServer(::grpc::ServerInitializer* si) GRPC_OVERRIDE; void InitServer(::grpc::ServerInitializer* si) override;
void Finish(::grpc::ServerInitializer* si) GRPC_OVERRIDE; void Finish(::grpc::ServerInitializer* si) override;
void ChangeArguments(const ::grpc::string& name, void* value) GRPC_OVERRIDE; void ChangeArguments(const ::grpc::string& name, void* value) override;
bool has_async_methods() const GRPC_OVERRIDE; bool has_async_methods() const override;
bool has_sync_methods() const GRPC_OVERRIDE; bool has_sync_methods() const override;
private: private:
std::shared_ptr<grpc::ProtoServerReflection> reflection_service_; std::shared_ptr<grpc::ProtoServerReflection> reflection_service_;

@ -44,7 +44,7 @@ namespace grpc {
typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer> typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
GenericServerAsyncReaderWriter; GenericServerAsyncReaderWriter;
class GenericServerContext GRPC_FINAL : public ServerContext { class GenericServerContext final : public ServerContext {
public: public:
const grpc::string& method() const { return method_; } const grpc::string& method() const { return method_; }
const grpc::string& host() const { return host_; } const grpc::string& host() const { return host_; }
@ -57,7 +57,7 @@ class GenericServerContext GRPC_FINAL : public ServerContext {
grpc::string host_; grpc::string host_;
}; };
class AsyncGenericService GRPC_FINAL { class AsyncGenericService final {
public: public:
AsyncGenericService() : server_(nullptr) {} AsyncGenericService() : server_(nullptr) {}

@ -45,7 +45,7 @@ typedef ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
// Generic stubs provide a type-unsafe interface to call gRPC methods // Generic stubs provide a type-unsafe interface to call gRPC methods
// by name. // by name.
class GenericStub GRPC_FINAL { class GenericStub final {
public: public:
explicit GenericStub(std::shared_ptr<ChannelInterface> channel) explicit GenericStub(std::shared_ptr<ChannelInterface> channel)
: channel_(channel) {} : channel_(channel) {}

@ -108,7 +108,7 @@ class ClientAsyncReaderInterface : public ClientAsyncStreamingInterface,
public AsyncReaderInterface<R> {}; public AsyncReaderInterface<R> {};
template <class R> template <class R>
class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> { class ClientAsyncReader final : public ClientAsyncReaderInterface<R> {
public: public:
/// Create a stream and write the first request out. /// Create a stream and write the first request out.
template <class W> template <class W>
@ -125,7 +125,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> {
call_.PerformOps(&init_ops_); call_.PerformOps(&init_ops_);
} }
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -133,7 +133,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
read_ops_.RecvInitialMetadata(context_); read_ops_.RecvInitialMetadata(context_);
@ -142,7 +142,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> {
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Finish(Status* status, void* tag) GRPC_OVERRIDE { void Finish(Status* status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -174,7 +174,7 @@ class ClientAsyncWriterInterface : public ClientAsyncStreamingInterface,
}; };
template <class W> template <class W>
class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> { class ClientAsyncWriter final : public ClientAsyncWriterInterface<W> {
public: public:
template <class R> template <class R>
ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq, ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq,
@ -190,7 +190,7 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> {
call_.PerformOps(&init_ops_); call_.PerformOps(&init_ops_);
} }
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -198,20 +198,20 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
// TODO(ctiller): don't assert // TODO(ctiller): don't assert
GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok()); GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void WritesDone(void* tag) GRPC_OVERRIDE { void WritesDone(void* tag) override {
writes_done_ops_.set_output_tag(tag); writes_done_ops_.set_output_tag(tag);
writes_done_ops_.ClientSendClose(); writes_done_ops_.ClientSendClose();
call_.PerformOps(&writes_done_ops_); call_.PerformOps(&writes_done_ops_);
} }
void Finish(Status* status, void* tag) GRPC_OVERRIDE { void Finish(Status* status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -246,7 +246,7 @@ class ClientAsyncReaderWriterInterface : public ClientAsyncStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ClientAsyncReaderWriter GRPC_FINAL class ClientAsyncReaderWriter final
: public ClientAsyncReaderWriterInterface<W, R> { : public ClientAsyncReaderWriterInterface<W, R> {
public: public:
ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq, ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq,
@ -259,7 +259,7 @@ class ClientAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&init_ops_); call_.PerformOps(&init_ops_);
} }
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -267,7 +267,7 @@ class ClientAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
read_ops_.RecvInitialMetadata(context_); read_ops_.RecvInitialMetadata(context_);
@ -276,20 +276,20 @@ class ClientAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
// TODO(ctiller): don't assert // TODO(ctiller): don't assert
GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok()); GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void WritesDone(void* tag) GRPC_OVERRIDE { void WritesDone(void* tag) override {
writes_done_ops_.set_output_tag(tag); writes_done_ops_.set_output_tag(tag);
writes_done_ops_.ClientSendClose(); writes_done_ops_.ClientSendClose();
call_.PerformOps(&writes_done_ops_); call_.PerformOps(&writes_done_ops_);
} }
void Finish(Status* status, void* tag) GRPC_OVERRIDE { void Finish(Status* status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -319,12 +319,12 @@ class ServerAsyncReaderInterface : public ServerAsyncStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> { class ServerAsyncReader final : public ServerAsyncReaderInterface<W, R> {
public: public:
explicit ServerAsyncReader(ServerContext* ctx) explicit ServerAsyncReader(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -337,13 +337,13 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
read_ops_.RecvMessage(msg); read_ops_.RecvMessage(msg);
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Finish(const W& msg, const Status& status, void* tag) GRPC_OVERRIDE { void Finish(const W& msg, const Status& status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_, finish_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -363,7 +363,7 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> {
call_.PerformOps(&finish_ops_); call_.PerformOps(&finish_ops_);
} }
void FinishWithError(const Status& status, void* tag) GRPC_OVERRIDE { void FinishWithError(const Status& status, void* tag) override {
GPR_CODEGEN_ASSERT(!status.ok()); GPR_CODEGEN_ASSERT(!status.ok());
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
@ -379,7 +379,7 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> {
} }
private: private:
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;
@ -398,12 +398,12 @@ class ServerAsyncWriterInterface : public ServerAsyncStreamingInterface,
}; };
template <class W> template <class W>
class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> { class ServerAsyncWriter final : public ServerAsyncWriterInterface<W> {
public: public:
explicit ServerAsyncWriter(ServerContext* ctx) explicit ServerAsyncWriter(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -416,7 +416,7 @@ class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
write_ops_.SendInitialMetadata(ctx_->initial_metadata_, write_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -431,7 +431,7 @@ class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> {
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void Finish(const Status& status, void* tag) GRPC_OVERRIDE { void Finish(const Status& status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_, finish_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -446,7 +446,7 @@ class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> {
} }
private: private:
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;
@ -465,13 +465,13 @@ class ServerAsyncReaderWriterInterface : public ServerAsyncStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ServerAsyncReaderWriter GRPC_FINAL class ServerAsyncReaderWriter final
: public ServerAsyncReaderWriterInterface<W, R> { : public ServerAsyncReaderWriterInterface<W, R> {
public: public:
explicit ServerAsyncReaderWriter(ServerContext* ctx) explicit ServerAsyncReaderWriter(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -484,13 +484,13 @@ class ServerAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
read_ops_.RecvMessage(msg); read_ops_.RecvMessage(msg);
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
write_ops_.SendInitialMetadata(ctx_->initial_metadata_, write_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -505,7 +505,7 @@ class ServerAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void Finish(const Status& status, void* tag) GRPC_OVERRIDE { void Finish(const Status& status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_, finish_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -522,7 +522,7 @@ class ServerAsyncReaderWriter GRPC_FINAL
private: private:
friend class ::grpc::Server; friend class ::grpc::Server;
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;

@ -55,7 +55,7 @@ class ClientAsyncResponseReaderInterface {
}; };
template <class R> template <class R>
class ClientAsyncResponseReader GRPC_FINAL class ClientAsyncResponseReader final
: public ClientAsyncResponseReaderInterface<R> { : public ClientAsyncResponseReaderInterface<R> {
public: public:
template <class W> template <class W>
@ -113,13 +113,12 @@ class ClientAsyncResponseReader GRPC_FINAL
}; };
template <class W> template <class W>
class ServerAsyncResponseWriter GRPC_FINAL class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface {
: public ServerAsyncStreamingInterface {
public: public:
explicit ServerAsyncResponseWriter(ServerContext* ctx) explicit ServerAsyncResponseWriter(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_buf_.set_output_tag(tag); meta_buf_.set_output_tag(tag);
@ -168,7 +167,7 @@ class ServerAsyncResponseWriter GRPC_FINAL
} }
private: private:
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;

@ -337,16 +337,16 @@ class DeserializeFunc {
}; };
template <class R> template <class R>
class DeserializeFuncType GRPC_FINAL : public DeserializeFunc { class DeserializeFuncType final : public DeserializeFunc {
public: public:
DeserializeFuncType(R* message) : message_(message) {} DeserializeFuncType(R* message) : message_(message) {}
Status Deserialize(grpc_byte_buffer* buf, Status Deserialize(grpc_byte_buffer* buf,
int max_receive_message_size) GRPC_OVERRIDE { int max_receive_message_size) override {
return SerializationTraits<R>::Deserialize(buf, message_, return SerializationTraits<R>::Deserialize(buf, message_,
max_receive_message_size); max_receive_message_size);
} }
~DeserializeFuncType() GRPC_OVERRIDE {} ~DeserializeFuncType() override {}
private: private:
R* message_; // Not a managed pointer because management is external to this R* message_; // Not a managed pointer because management is external to this
@ -603,7 +603,7 @@ class CallOpSet : public CallOpSetInterface,
public Op6 { public Op6 {
public: public:
CallOpSet() : return_tag_(this) {} CallOpSet() : return_tag_(this) {}
void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE { void FillOps(grpc_op* ops, size_t* nops) override {
this->Op1::AddOp(ops, nops); this->Op1::AddOp(ops, nops);
this->Op2::AddOp(ops, nops); this->Op2::AddOp(ops, nops);
this->Op3::AddOp(ops, nops); this->Op3::AddOp(ops, nops);
@ -612,7 +612,7 @@ class CallOpSet : public CallOpSetInterface,
this->Op6::AddOp(ops, nops); this->Op6::AddOp(ops, nops);
} }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
this->Op1::FinishOp(status, max_receive_message_size_); this->Op1::FinishOp(status, max_receive_message_size_);
this->Op2::FinishOp(status, max_receive_message_size_); this->Op2::FinishOp(status, max_receive_message_size_);
this->Op3::FinishOp(status, max_receive_message_size_); this->Op3::FinishOp(status, max_receive_message_size_);
@ -639,14 +639,14 @@ template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>,
class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>> class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>>
class SneakyCallOpSet : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> { class SneakyCallOpSet : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> {
public: public:
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
typedef CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> Base; typedef CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> Base;
return Base::FinalizeResult(tag, status) && false; return Base::FinalizeResult(tag, status) && false;
} }
}; };
// Straightforward wrapping of the C call object // Straightforward wrapping of the C call object
class Call GRPC_FINAL { class Call final {
public: public:
/* call is owned by the caller */ /* call is owned by the caller */
Call(grpc_call* call, CallHook* call_hook, CompletionQueue* cq) Call(grpc_call* call, CallHook* call_hook, CompletionQueue* cq)

@ -51,6 +51,7 @@
#include <map> #include <map>
#include <memory> #include <memory>
#include <mutex>
#include <string> #include <string>
#include <grpc++/impl/codegen/config.h> #include <grpc++/impl/codegen/config.h>
@ -59,7 +60,6 @@
#include <grpc++/impl/codegen/security/auth_context.h> #include <grpc++/impl/codegen/security/auth_context.h>
#include <grpc++/impl/codegen/status.h> #include <grpc++/impl/codegen/status.h>
#include <grpc++/impl/codegen/string_ref.h> #include <grpc++/impl/codegen/string_ref.h>
#include <grpc++/impl/codegen/sync.h>
#include <grpc++/impl/codegen/time.h> #include <grpc++/impl/codegen/time.h>
#include <grpc/impl/codegen/compression_types.h> #include <grpc/impl/codegen/compression_types.h>
#include <grpc/impl/codegen/propagation_bits.h> #include <grpc/impl/codegen/propagation_bits.h>
@ -235,12 +235,10 @@ class ClientContext {
/// DEPRECATED: Use set_wait_for_ready() instead. /// DEPRECATED: Use set_wait_for_ready() instead.
void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); } void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); }
#ifndef GRPC_CXX0X_NO_CHRONO
/// Return the deadline for the client call. /// Return the deadline for the client call.
std::chrono::system_clock::time_point deadline() const { std::chrono::system_clock::time_point deadline() const {
return Timespec2Timepoint(deadline_); return Timespec2Timepoint(deadline_);
} }
#endif // !GRPC_CXX0X_NO_CHRONO
/// Return a \a gpr_timespec representation of the client call's deadline. /// Return a \a gpr_timespec representation of the client call's deadline.
gpr_timespec raw_deadline() const { return deadline_; } gpr_timespec raw_deadline() const { return deadline_; }
@ -368,7 +366,7 @@ class ClientContext {
bool idempotent_; bool idempotent_;
bool cacheable_; bool cacheable_;
std::shared_ptr<Channel> channel_; std::shared_ptr<Channel> channel_;
grpc::mutex mu_; std::mutex mu_;
grpc_call* call_; grpc_call* call_;
bool call_canceled_; bool call_canceled_;
gpr_timespec deadline_; gpr_timespec deadline_;

@ -34,80 +34,6 @@
#ifndef GRPCXX_IMPL_CODEGEN_CONFIG_H #ifndef GRPCXX_IMPL_CODEGEN_CONFIG_H
#define GRPCXX_IMPL_CODEGEN_CONFIG_H #define GRPCXX_IMPL_CODEGEN_CONFIG_H
#if !defined(GRPC_NO_AUTODETECT_PLATFORM)
#ifdef _MSC_VER
// Visual Studio 2010 is 1600.
#if _MSC_VER < 1600
#error "gRPC is only supported with Visual Studio starting at 2010"
// Visual Studio 2013 is 1800.
#elif _MSC_VER < 1800
#define GRPC_CXX0X_NO_FINAL 1
#define GRPC_CXX0X_NO_OVERRIDE 1
#define GRPC_CXX0X_NO_CHRONO 1
#define GRPC_CXX0X_NO_THREAD 1
#endif
#endif // Visual Studio
#ifndef __clang__
#ifdef __GNUC__
// nullptr was added in gcc 4.6
#if (__GNUC__ * 100 + __GNUC_MINOR__ < 406)
#define GRPC_CXX0X_NO_NULLPTR 1
#define GRPC_CXX0X_LIMITED_TOSTRING 1
#endif
// final and override were added in gcc 4.7
#if (__GNUC__ * 100 + __GNUC_MINOR__ < 407)
#define GRPC_CXX0X_NO_FINAL 1
#define GRPC_CXX0X_NO_OVERRIDE 1
#endif
#endif
#endif
#endif
#ifdef GRPC_CXX0X_NO_FINAL
#define GRPC_FINAL
#else
#define GRPC_FINAL final
#endif
#ifdef GRPC_CXX0X_NO_OVERRIDE
#define GRPC_OVERRIDE
#else
#define GRPC_OVERRIDE override
#endif
#ifdef GRPC_CXX0X_NO_NULLPTR
#include <functional>
#include <memory>
namespace grpc {
const class {
public:
template <class T>
operator T *() const {
return static_cast<T *>(0);
}
template <class T>
operator std::unique_ptr<T>() const {
return std::unique_ptr<T>(static_cast<T *>(0));
}
template <class T>
operator std::shared_ptr<T>() const {
return std::shared_ptr<T>(static_cast<T *>(0));
}
operator bool() const { return false; }
template <class F>
operator std::function<F>() const {
return std::function<F>();
}
private:
void operator&() const = delete;
} nullptr = {};
}
#endif
#ifndef GRPC_CUSTOM_STRING #ifndef GRPC_CUSTOM_STRING
#include <string> #include <string>
#define GRPC_CUSTOM_STRING std::string #define GRPC_CUSTOM_STRING std::string
@ -117,16 +43,7 @@ namespace grpc {
typedef GRPC_CUSTOM_STRING string; typedef GRPC_CUSTOM_STRING string;
#ifdef GRPC_CXX0X_LIMITED_TOSTRING
inline grpc::string to_string(const int x) {
return std::to_string(static_cast<const long long int>(x));
}
inline grpc::string to_string(const unsigned int x) {
return std::to_string(static_cast<const long long unsigned int>(x));
}
#else
using std::to_string; using std::to_string;
#endif
} // namespace grpc } // namespace grpc

@ -45,56 +45,53 @@ namespace grpc {
/// Implementation of the core codegen interface. /// Implementation of the core codegen interface.
class CoreCodegen : public CoreCodegenInterface { class CoreCodegen : public CoreCodegenInterface {
private: private:
grpc_completion_queue* grpc_completion_queue_create(void* reserved) grpc_completion_queue* grpc_completion_queue_create(void* reserved) override;
GRPC_OVERRIDE; void grpc_completion_queue_destroy(grpc_completion_queue* cq) override;
void grpc_completion_queue_destroy(grpc_completion_queue* cq) GRPC_OVERRIDE;
grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag, grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
gpr_timespec deadline, gpr_timespec deadline,
void* reserved) GRPC_OVERRIDE; void* reserved) override;
void* gpr_malloc(size_t size) GRPC_OVERRIDE; void* gpr_malloc(size_t size) override;
void gpr_free(void* p) GRPC_OVERRIDE; void gpr_free(void* p) override;
void gpr_mu_init(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_init(gpr_mu* mu) override;
void gpr_mu_destroy(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_destroy(gpr_mu* mu) override;
void gpr_mu_lock(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_lock(gpr_mu* mu) override;
void gpr_mu_unlock(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_unlock(gpr_mu* mu) override;
void gpr_cv_init(gpr_cv* cv) GRPC_OVERRIDE; void gpr_cv_init(gpr_cv* cv) override;
void gpr_cv_destroy(gpr_cv* cv) GRPC_OVERRIDE; void gpr_cv_destroy(gpr_cv* cv) override;
int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) override;
gpr_timespec abs_deadline) GRPC_OVERRIDE; void gpr_cv_signal(gpr_cv* cv) override;
void gpr_cv_signal(gpr_cv* cv) GRPC_OVERRIDE; void gpr_cv_broadcast(gpr_cv* cv) override;
void gpr_cv_broadcast(gpr_cv* cv) GRPC_OVERRIDE;
void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) GRPC_OVERRIDE; void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) override;
int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader, int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
grpc_byte_buffer* buffer) GRPC_OVERRIDE; grpc_byte_buffer* buffer) override;
void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader) void grpc_byte_buffer_reader_destroy(
GRPC_OVERRIDE; grpc_byte_buffer_reader* reader) override;
int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader, int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
gpr_slice* slice) GRPC_OVERRIDE; gpr_slice* slice) override;
grpc_byte_buffer* grpc_raw_byte_buffer_create(gpr_slice* slice, grpc_byte_buffer* grpc_raw_byte_buffer_create(gpr_slice* slice,
size_t nslices) GRPC_OVERRIDE; size_t nslices) override;
gpr_slice gpr_slice_malloc(size_t length) GRPC_OVERRIDE; gpr_slice gpr_slice_malloc(size_t length) override;
void gpr_slice_unref(gpr_slice slice) GRPC_OVERRIDE; void gpr_slice_unref(gpr_slice slice) override;
gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) GRPC_OVERRIDE; gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) override;
void gpr_slice_buffer_add(gpr_slice_buffer* sb, void gpr_slice_buffer_add(gpr_slice_buffer* sb, gpr_slice slice) override;
gpr_slice slice) GRPC_OVERRIDE; void gpr_slice_buffer_pop(gpr_slice_buffer* sb) override;
void gpr_slice_buffer_pop(gpr_slice_buffer* sb) GRPC_OVERRIDE;
void grpc_metadata_array_init(grpc_metadata_array* array) GRPC_OVERRIDE; void grpc_metadata_array_init(grpc_metadata_array* array) override;
void grpc_metadata_array_destroy(grpc_metadata_array* array) GRPC_OVERRIDE; void grpc_metadata_array_destroy(grpc_metadata_array* array) override;
gpr_timespec gpr_inf_future(gpr_clock_type type) GRPC_OVERRIDE; gpr_timespec gpr_inf_future(gpr_clock_type type) override;
gpr_timespec gpr_time_0(gpr_clock_type type) GRPC_OVERRIDE; gpr_timespec gpr_time_0(gpr_clock_type type) override;
virtual const Status& ok() GRPC_OVERRIDE; virtual const Status& ok() override;
virtual const Status& cancelled() GRPC_OVERRIDE; virtual const Status& cancelled() override;
void assert_fail(const char* failed_assertion) GRPC_OVERRIDE; void assert_fail(const char* failed_assertion) override;
}; };
} // namespace grpc } // namespace grpc

@ -1,45 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_IMPL_SYNC_H
#define GRPCXX_IMPL_CODEGEN_IMPL_SYNC_H
#include <grpc++/impl/codegen/config.h>
#ifdef GRPC_CXX0X_NO_THREAD
#include <grpc++/impl/codegen/sync_no_cxx11.h>
#else
#include <grpc++/impl/codegen/sync_cxx11.h>
#endif
#endif // GRPCXX_IMPL_CODEGEN_IMPL_SYNC_H

@ -50,7 +50,7 @@ class RpcMethodHandler : public MethodHandler {
ServiceType* service) ServiceType* service)
: func_(func), service_(service) {} : func_(func), service_(service) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
RequestType req; RequestType req;
Status status = SerializationTraits<RequestType>::Deserialize( Status status = SerializationTraits<RequestType>::Deserialize(
param.request, &req, param.max_receive_message_size); param.request, &req, param.max_receive_message_size);
@ -96,7 +96,7 @@ class ClientStreamingHandler : public MethodHandler {
ServiceType* service) ServiceType* service)
: func_(func), service_(service) {} : func_(func), service_(service) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
ServerReader<RequestType> reader(param.call, param.server_context); ServerReader<RequestType> reader(param.call, param.server_context);
ResponseType rsp; ResponseType rsp;
Status status = func_(service_, param.server_context, &reader, &rsp); Status status = func_(service_, param.server_context, &reader, &rsp);
@ -136,7 +136,7 @@ class ServerStreamingHandler : public MethodHandler {
ServiceType* service) ServiceType* service)
: func_(func), service_(service) {} : func_(func), service_(service) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
RequestType req; RequestType req;
Status status = SerializationTraits<RequestType>::Deserialize( Status status = SerializationTraits<RequestType>::Deserialize(
param.request, &req, param.max_receive_message_size); param.request, &req, param.max_receive_message_size);
@ -180,7 +180,7 @@ class TemplatedBidiStreamingHandler : public MethodHandler {
std::function<Status(ServerContext*, Streamer*)> func) std::function<Status(ServerContext*, Streamer*)> func)
: func_(func), write_needed_(WriteNeeded) {} : func_(func), write_needed_(WriteNeeded) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
Streamer stream(param.call, param.server_context); Streamer stream(param.call, param.server_context);
Status status = func_(param.server_context, &stream); Status status = func_(param.server_context, &stream);
@ -266,7 +266,7 @@ class UnknownMethodHandler : public MethodHandler {
ops->ServerSendStatus(context->trailing_metadata_, status); ops->ServerSendStatus(context->trailing_metadata_, status);
} }
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops; CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops;
FillOps(param.server_context, &ops); FillOps(param.server_context, &ops);
param.call->PerformOps(&ops); param.call->PerformOps(&ops);

@ -52,7 +52,7 @@ namespace internal {
const int kGrpcBufferWriterMaxBufferLength = 8192; const int kGrpcBufferWriterMaxBufferLength = 8192;
class GrpcBufferWriter GRPC_FINAL class GrpcBufferWriter final
: public ::grpc::protobuf::io::ZeroCopyOutputStream { : public ::grpc::protobuf::io::ZeroCopyOutputStream {
public: public:
explicit GrpcBufferWriter(grpc_byte_buffer** bp, int block_size) explicit GrpcBufferWriter(grpc_byte_buffer** bp, int block_size)
@ -61,13 +61,13 @@ class GrpcBufferWriter GRPC_FINAL
slice_buffer_ = &(*bp)->data.raw.slice_buffer; slice_buffer_ = &(*bp)->data.raw.slice_buffer;
} }
~GrpcBufferWriter() GRPC_OVERRIDE { ~GrpcBufferWriter() override {
if (have_backup_) { if (have_backup_) {
g_core_codegen_interface->gpr_slice_unref(backup_slice_); g_core_codegen_interface->gpr_slice_unref(backup_slice_);
} }
} }
bool Next(void** data, int* size) GRPC_OVERRIDE { bool Next(void** data, int* size) override {
if (have_backup_) { if (have_backup_) {
slice_ = backup_slice_; slice_ = backup_slice_;
have_backup_ = false; have_backup_ = false;
@ -82,7 +82,7 @@ class GrpcBufferWriter GRPC_FINAL
return true; return true;
} }
void BackUp(int count) GRPC_OVERRIDE { void BackUp(int count) override {
g_core_codegen_interface->gpr_slice_buffer_pop(slice_buffer_); g_core_codegen_interface->gpr_slice_buffer_pop(slice_buffer_);
if (count == block_size_) { if (count == block_size_) {
backup_slice_ = slice_; backup_slice_ = slice_;
@ -95,7 +95,7 @@ class GrpcBufferWriter GRPC_FINAL
byte_count_ -= count; byte_count_ -= count;
} }
grpc::protobuf::int64 ByteCount() const GRPC_OVERRIDE { return byte_count_; } grpc::protobuf::int64 ByteCount() const override { return byte_count_; }
private: private:
const int block_size_; const int block_size_;
@ -106,7 +106,7 @@ class GrpcBufferWriter GRPC_FINAL
gpr_slice slice_; gpr_slice slice_;
}; };
class GrpcBufferReader GRPC_FINAL class GrpcBufferReader final
: public ::grpc::protobuf::io::ZeroCopyInputStream { : public ::grpc::protobuf::io::ZeroCopyInputStream {
public: public:
explicit GrpcBufferReader(grpc_byte_buffer* buffer) explicit GrpcBufferReader(grpc_byte_buffer* buffer)
@ -117,11 +117,11 @@ class GrpcBufferReader GRPC_FINAL
"Couldn't initialize byte buffer reader"); "Couldn't initialize byte buffer reader");
} }
} }
~GrpcBufferReader() GRPC_OVERRIDE { ~GrpcBufferReader() override {
g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_); g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
} }
bool Next(const void** data, int* size) GRPC_OVERRIDE { bool Next(const void** data, int* size) override {
if (!status_.ok()) { if (!status_.ok()) {
return false; return false;
} }
@ -147,9 +147,9 @@ class GrpcBufferReader GRPC_FINAL
Status status() const { return status_; } Status status() const { return status_; }
void BackUp(int count) GRPC_OVERRIDE { backup_count_ = count; } void BackUp(int count) override { backup_count_ = count; }
bool Skip(int count) GRPC_OVERRIDE { bool Skip(int count) override {
const void* data; const void* data;
int size; int size;
while (Next(&data, &size)) { while (Next(&data, &size)) {
@ -164,7 +164,7 @@ class GrpcBufferReader GRPC_FINAL
return false; return false;
} }
grpc::protobuf::int64 ByteCount() const GRPC_OVERRIDE { grpc::protobuf::int64 ByteCount() const override {
return byte_count_ - backup_count_; return byte_count_ - backup_count_;
} }

@ -94,11 +94,9 @@ class ServerContext {
ServerContext(); // for async calls ServerContext(); // for async calls
~ServerContext(); ~ServerContext();
#ifndef GRPC_CXX0X_NO_CHRONO
std::chrono::system_clock::time_point deadline() const { std::chrono::system_clock::time_point deadline() const {
return Timespec2Timepoint(deadline_); return Timespec2Timepoint(deadline_);
} }
#endif // !GRPC_CXX0X_NO_CHRONO
gpr_timespec raw_deadline() const { return deadline_; } gpr_timespec raw_deadline() const { return deadline_; }

@ -142,7 +142,7 @@ class ServerInterface : public CallHook {
bool delete_on_finalize); bool delete_on_finalize);
virtual ~BaseAsyncRequest() {} virtual ~BaseAsyncRequest() {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
protected: protected:
ServerInterface* const server_; ServerInterface* const server_;
@ -168,7 +168,7 @@ class ServerInterface : public CallHook {
ServerCompletionQueue* notification_cq); ServerCompletionQueue* notification_cq);
}; };
class NoPayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { class NoPayloadAsyncRequest final : public RegisteredAsyncRequest {
public: public:
NoPayloadAsyncRequest(void* registered_method, ServerInterface* server, NoPayloadAsyncRequest(void* registered_method, ServerInterface* server,
ServerContext* context, ServerContext* context,
@ -183,7 +183,7 @@ class ServerInterface : public CallHook {
}; };
template <class Message> template <class Message>
class PayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { class PayloadAsyncRequest final : public RegisteredAsyncRequest {
public: public:
PayloadAsyncRequest(void* registered_method, ServerInterface* server, PayloadAsyncRequest(void* registered_method, ServerInterface* server,
ServerContext* context, ServerContext* context,
@ -196,7 +196,7 @@ class ServerInterface : public CallHook {
IssueRequest(registered_method, &payload_, notification_cq); IssueRequest(registered_method, &payload_, notification_cq);
} }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
bool serialization_status = bool serialization_status =
*status && payload_ && *status && payload_ &&
SerializationTraits<Message>::Deserialize( SerializationTraits<Message>::Deserialize(
@ -220,7 +220,7 @@ class ServerInterface : public CallHook {
ServerCompletionQueue* notification_cq, void* tag, ServerCompletionQueue* notification_cq, void* tag,
bool delete_on_finalize); bool delete_on_finalize);
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
private: private:
grpc_call_details call_details_; grpc_call_details call_details_;

@ -1,45 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_H
#define GRPCXX_IMPL_CODEGEN_SYNC_H
#include <grpc++/impl/codegen/config.h>
#ifdef GRPC_CXX0X_NO_THREAD
#include <grpc++/impl/codegen/sync_no_cxx11.h>
#else
#include <grpc++/impl/codegen/sync_cxx11.h>
#endif
#endif // GRPCXX_IMPL_CODEGEN_SYNC_H

@ -1,49 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H
#define GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H
#include <condition_variable>
#include <mutex>
namespace grpc {
using std::condition_variable;
using std::mutex;
using std::lock_guard;
using std::unique_lock;
} // namespace grpc
#endif // GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H

@ -1,111 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H
#define GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H
#include <grpc++/impl/codegen/core_codegen_interface.h>
namespace grpc {
extern CoreCodegenInterface *g_core_codegen_interface;
template <class mutex>
class lock_guard;
class condition_variable;
class mutex {
public:
mutex() { g_core_codegen_interface->gpr_mu_init(&mu_); }
~mutex() { g_core_codegen_interface->gpr_mu_destroy(&mu_); }
private:
::gpr_mu mu_;
template <class mutex>
friend class lock_guard;
friend class condition_variable;
};
template <class mutex>
class lock_guard {
public:
lock_guard(mutex &mu) : mu_(mu), locked(true) {
g_core_codegen_interface->gpr_mu_lock(&mu.mu_);
}
~lock_guard() { unlock_internal(); }
protected:
void lock_internal() {
if (!locked) g_core_codegen_interface->gpr_mu_lock(&mu_.mu_);
locked = true;
}
void unlock_internal() {
if (locked) g_core_codegen_interface->gpr_mu_unlock(&mu_.mu_);
locked = false;
}
private:
mutex &mu_;
bool locked;
friend class condition_variable;
};
template <class mutex>
class unique_lock : public lock_guard<mutex> {
public:
unique_lock(mutex &mu) : lock_guard<mutex>(mu) {}
void lock() { this->lock_internal(); }
void unlock() { this->unlock_internal(); }
};
class condition_variable {
public:
condition_variable() { g_core_codegen_interface->gpr_cv_init(&cv_); }
~condition_variable() { g_core_codegen_interface->gpr_cv_destroy(&cv_); }
void wait(lock_guard<mutex> &mu) {
mu.locked = false;
g_core_codegen_interface->gpr_cv_wait(
&cv_, &mu.mu_.mu_,
g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME));
mu.locked = true;
}
void notify_one() { g_core_codegen_interface->gpr_cv_signal(&cv_); }
void notify_all() { g_core_codegen_interface->gpr_cv_broadcast(&cv_); }
private:
gpr_cv cv_;
};
} // namespace grpc
#endif // GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H

@ -131,7 +131,7 @@ class ClientReaderInterface : public ClientStreamingInterface,
}; };
template <class R> template <class R>
class ClientReader GRPC_FINAL : public ClientReaderInterface<R> { class ClientReader final : public ClientReaderInterface<R> {
public: public:
/// Blocking create a stream and write the first request out. /// Blocking create a stream and write the first request out.
template <class W> template <class W>
@ -150,7 +150,7 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
cq_.Pluck(&ops); cq_.Pluck(&ops);
} }
void WaitForInitialMetadata() GRPC_OVERRIDE { void WaitForInitialMetadata() override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
CallOpSet<CallOpRecvInitialMetadata> ops; CallOpSet<CallOpRecvInitialMetadata> ops;
@ -159,12 +159,12 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
cq_.Pluck(&ops); /// status ignored cq_.Pluck(&ops); /// status ignored
} }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = call_.max_receive_message_size(); *sz = call_.max_receive_message_size();
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { bool Read(R* msg) override {
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops; CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
ops.RecvInitialMetadata(context_); ops.RecvInitialMetadata(context_);
@ -174,7 +174,7 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
return cq_.Pluck(&ops) && ops.got_message; return cq_.Pluck(&ops) && ops.got_message;
} }
Status Finish() GRPC_OVERRIDE { Status Finish() override {
CallOpSet<CallOpClientRecvStatus> ops; CallOpSet<CallOpClientRecvStatus> ops;
Status status; Status status;
ops.ClientRecvStatus(context_, &status); ops.ClientRecvStatus(context_, &status);
@ -230,7 +230,7 @@ class ClientWriter : public ClientWriterInterface<W> {
} }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
CallOpSet<CallOpSendMessage> ops; CallOpSet<CallOpSendMessage> ops;
if (!ops.SendMessage(msg, options).ok()) { if (!ops.SendMessage(msg, options).ok()) {
return false; return false;
@ -239,7 +239,7 @@ class ClientWriter : public ClientWriterInterface<W> {
return cq_.Pluck(&ops); return cq_.Pluck(&ops);
} }
bool WritesDone() GRPC_OVERRIDE { bool WritesDone() override {
CallOpSet<CallOpClientSendClose> ops; CallOpSet<CallOpClientSendClose> ops;
ops.ClientSendClose(); ops.ClientSendClose();
call_.PerformOps(&ops); call_.PerformOps(&ops);
@ -247,7 +247,7 @@ class ClientWriter : public ClientWriterInterface<W> {
} }
/// Read the final response and wait for the final status. /// Read the final response and wait for the final status.
Status Finish() GRPC_OVERRIDE { Status Finish() override {
Status status; Status status;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -287,7 +287,7 @@ class ClientReaderWriterInterface : public ClientStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> { class ClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
public: public:
/// Blocking create a stream. /// Blocking create a stream.
ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method, ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method,
@ -300,7 +300,7 @@ class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> {
cq_.Pluck(&ops); cq_.Pluck(&ops);
} }
void WaitForInitialMetadata() GRPC_OVERRIDE { void WaitForInitialMetadata() override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
CallOpSet<CallOpRecvInitialMetadata> ops; CallOpSet<CallOpRecvInitialMetadata> ops;
@ -309,12 +309,12 @@ class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> {
cq_.Pluck(&ops); // status ignored cq_.Pluck(&ops); // status ignored
} }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = call_.max_receive_message_size(); *sz = call_.max_receive_message_size();
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { bool Read(R* msg) override {
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops; CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
ops.RecvInitialMetadata(context_); ops.RecvInitialMetadata(context_);
@ -325,21 +325,21 @@ class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> {
} }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
CallOpSet<CallOpSendMessage> ops; CallOpSet<CallOpSendMessage> ops;
if (!ops.SendMessage(msg, options).ok()) return false; if (!ops.SendMessage(msg, options).ok()) return false;
call_.PerformOps(&ops); call_.PerformOps(&ops);
return cq_.Pluck(&ops); return cq_.Pluck(&ops);
} }
bool WritesDone() GRPC_OVERRIDE { bool WritesDone() override {
CallOpSet<CallOpClientSendClose> ops; CallOpSet<CallOpClientSendClose> ops;
ops.ClientSendClose(); ops.ClientSendClose();
call_.PerformOps(&ops); call_.PerformOps(&ops);
return cq_.Pluck(&ops); return cq_.Pluck(&ops);
} }
Status Finish() GRPC_OVERRIDE { Status Finish() override {
CallOpSet<CallOpRecvInitialMetadata, CallOpClientRecvStatus> ops; CallOpSet<CallOpRecvInitialMetadata, CallOpClientRecvStatus> ops;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
ops.RecvInitialMetadata(context_); ops.RecvInitialMetadata(context_);
@ -363,11 +363,11 @@ class ServerReaderInterface : public ServerStreamingInterface,
public ReaderInterface<R> {}; public ReaderInterface<R> {};
template <class R> template <class R>
class ServerReader GRPC_FINAL : public ServerReaderInterface<R> { class ServerReader final : public ServerReaderInterface<R> {
public: public:
ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
void SendInitialMetadata() GRPC_OVERRIDE { void SendInitialMetadata() override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
CallOpSet<CallOpSendInitialMetadata> ops; CallOpSet<CallOpSendInitialMetadata> ops;
@ -381,12 +381,12 @@ class ServerReader GRPC_FINAL : public ServerReaderInterface<R> {
call_->cq()->Pluck(&ops); call_->cq()->Pluck(&ops);
} }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = call_->max_receive_message_size(); *sz = call_->max_receive_message_size();
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { bool Read(R* msg) override {
CallOpSet<CallOpRecvMessage<R>> ops; CallOpSet<CallOpRecvMessage<R>> ops;
ops.RecvMessage(msg); ops.RecvMessage(msg);
call_->PerformOps(&ops); call_->PerformOps(&ops);
@ -404,11 +404,11 @@ class ServerWriterInterface : public ServerStreamingInterface,
public WriterInterface<W> {}; public WriterInterface<W> {};
template <class W> template <class W>
class ServerWriter GRPC_FINAL : public ServerWriterInterface<W> { class ServerWriter final : public ServerWriterInterface<W> {
public: public:
ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
void SendInitialMetadata() GRPC_OVERRIDE { void SendInitialMetadata() override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
CallOpSet<CallOpSendInitialMetadata> ops; CallOpSet<CallOpSendInitialMetadata> ops;
@ -423,7 +423,7 @@ class ServerWriter GRPC_FINAL : public ServerWriterInterface<W> {
} }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops; CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops;
if (!ops.SendMessage(msg, options).ok()) { if (!ops.SendMessage(msg, options).ok()) {
return false; return false;
@ -454,7 +454,7 @@ class ServerReaderWriterInterface : public ServerStreamingInterface,
// Actual implementation of bi-directional streaming // Actual implementation of bi-directional streaming
namespace internal { namespace internal {
template <class W, class R> template <class W, class R>
class ServerReaderWriterBody GRPC_FINAL { class ServerReaderWriterBody final {
public: public:
ServerReaderWriterBody(Call* call, ServerContext* ctx) ServerReaderWriterBody(Call* call, ServerContext* ctx)
: call_(call), ctx_(ctx) {} : call_(call), ctx_(ctx) {}
@ -510,20 +510,20 @@ class ServerReaderWriterBody GRPC_FINAL {
// class to represent the user API for a bidirectional streaming call // class to represent the user API for a bidirectional streaming call
template <class W, class R> template <class W, class R>
class ServerReaderWriter GRPC_FINAL : public ServerReaderWriterInterface<W, R> { class ServerReaderWriter final : public ServerReaderWriterInterface<W, R> {
public: public:
ServerReaderWriter(Call* call, ServerContext* ctx) : body_(call, ctx) {} ServerReaderWriter(Call* call, ServerContext* ctx) : body_(call, ctx) {}
void SendInitialMetadata() GRPC_OVERRIDE { body_.SendInitialMetadata(); } void SendInitialMetadata() override { body_.SendInitialMetadata(); }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
return body_.NextMessageSize(sz); return body_.NextMessageSize(sz);
} }
bool Read(R* msg) GRPC_OVERRIDE { return body_.Read(msg); } bool Read(R* msg) override { return body_.Read(msg); }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
return body_.Write(msg, options); return body_.Write(msg, options);
} }
@ -541,19 +541,19 @@ class ServerReaderWriter GRPC_FINAL : public ServerReaderWriterInterface<W, R> {
/// must have exactly 1 Read and exactly 1 Write, in that order, to function /// must have exactly 1 Read and exactly 1 Write, in that order, to function
/// correctly. Otherwise, the RPC is in error. /// correctly. Otherwise, the RPC is in error.
template <class RequestType, class ResponseType> template <class RequestType, class ResponseType>
class ServerUnaryStreamer GRPC_FINAL class ServerUnaryStreamer final
: public ServerReaderWriterInterface<ResponseType, RequestType> { : public ServerReaderWriterInterface<ResponseType, RequestType> {
public: public:
ServerUnaryStreamer(Call* call, ServerContext* ctx) ServerUnaryStreamer(Call* call, ServerContext* ctx)
: body_(call, ctx), read_done_(false), write_done_(false) {} : body_(call, ctx), read_done_(false), write_done_(false) {}
void SendInitialMetadata() GRPC_OVERRIDE { body_.SendInitialMetadata(); } void SendInitialMetadata() override { body_.SendInitialMetadata(); }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
return body_.NextMessageSize(sz); return body_.NextMessageSize(sz);
} }
bool Read(RequestType* request) GRPC_OVERRIDE { bool Read(RequestType* request) override {
if (read_done_) { if (read_done_) {
return false; return false;
} }
@ -563,7 +563,7 @@ class ServerUnaryStreamer GRPC_FINAL
using WriterInterface<ResponseType>::Write; using WriterInterface<ResponseType>::Write;
bool Write(const ResponseType& response, bool Write(const ResponseType& response,
const WriteOptions& options) GRPC_OVERRIDE { const WriteOptions& options) override {
if (write_done_ || !read_done_) { if (write_done_ || !read_done_) {
return false; return false;
} }
@ -583,19 +583,19 @@ class ServerUnaryStreamer GRPC_FINAL
/// but the server responds to it as though it were a bidi streaming call that /// but the server responds to it as though it were a bidi streaming call that
/// must first have exactly 1 Read and then any number of Writes. /// must first have exactly 1 Read and then any number of Writes.
template <class RequestType, class ResponseType> template <class RequestType, class ResponseType>
class ServerSplitStreamer GRPC_FINAL class ServerSplitStreamer final
: public ServerReaderWriterInterface<ResponseType, RequestType> { : public ServerReaderWriterInterface<ResponseType, RequestType> {
public: public:
ServerSplitStreamer(Call* call, ServerContext* ctx) ServerSplitStreamer(Call* call, ServerContext* ctx)
: body_(call, ctx), read_done_(false) {} : body_(call, ctx), read_done_(false) {}
void SendInitialMetadata() GRPC_OVERRIDE { body_.SendInitialMetadata(); } void SendInitialMetadata() override { body_.SendInitialMetadata(); }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
return body_.NextMessageSize(sz); return body_.NextMessageSize(sz);
} }
bool Read(RequestType* request) GRPC_OVERRIDE { bool Read(RequestType* request) override {
if (read_done_) { if (read_done_) {
return false; return false;
} }
@ -605,7 +605,7 @@ class ServerSplitStreamer GRPC_FINAL
using WriterInterface<ResponseType>::Write; using WriterInterface<ResponseType>::Write;
bool Write(const ResponseType& response, bool Write(const ResponseType& response,
const WriteOptions& options) GRPC_OVERRIDE { const WriteOptions& options) override {
return read_done_ && body_.Write(response, options); return read_done_ && body_.Write(response, options);
} }

@ -75,8 +75,6 @@ class TimePoint<gpr_timespec> {
} // namespace grpc } // namespace grpc
#ifndef GRPC_CXX0X_NO_CHRONO
#include <chrono> #include <chrono>
#include <grpc/impl/codegen/grpc_types.h> #include <grpc/impl/codegen/grpc_types.h>
@ -106,6 +104,4 @@ class TimePoint<std::chrono::system_clock::time_point> {
} // namespace grpc } // namespace grpc
#endif // !GRPC_CXX0X_NO_CHRONO
#endif // GRPCXX_IMPL_CODEGEN_TIME_H #endif // GRPCXX_IMPL_CODEGEN_TIME_H

@ -44,17 +44,17 @@
namespace grpc { namespace grpc {
namespace internal { namespace internal {
class GrpcLibrary GRPC_FINAL : public GrpcLibraryInterface { class GrpcLibrary final : public GrpcLibraryInterface {
public: public:
void init() GRPC_OVERRIDE { grpc_init(); } void init() override { grpc_init(); }
void shutdown() GRPC_OVERRIDE { grpc_shutdown(); } void shutdown() override { grpc_shutdown(); }
}; };
static GrpcLibrary g_gli; static GrpcLibrary g_gli;
static CoreCodegen g_core_codegen; static CoreCodegen g_core_codegen;
/// Instantiating this class ensures the proper initialization of gRPC. /// Instantiating this class ensures the proper initialization of gRPC.
class GrpcLibraryInitializer GRPC_FINAL { class GrpcLibraryInitializer final {
public: public:
GrpcLibraryInitializer() { GrpcLibraryInitializer() {
if (grpc::g_glip == nullptr) { if (grpc::g_glip == nullptr) {

@ -1,39 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_SYNC_H
#define GRPCXX_IMPL_SYNC_H
#include <grpc++/impl/codegen/sync.h>
#endif // GRPCXX_IMPL_SYNC_H

@ -1,45 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_THD_H
#define GRPCXX_IMPL_THD_H
#include <grpc++/support/config.h>
#ifdef GRPC_CXX0X_NO_THREAD
#include <grpc++/impl/thd_no_cxx11.h>
#else
#include <grpc++/impl/thd_cxx11.h>
#endif
#endif // GRPCXX_IMPL_THD_H

@ -1,45 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_THD_CXX11_H
#define GRPCXX_IMPL_THD_CXX11_H
#include <thread>
namespace grpc {
using std::thread;
} // namespace grpc
#endif // GRPCXX_IMPL_THD_CXX11_H

@ -1,117 +0,0 @@
/*
*
* 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.
*
*/
#ifndef GRPCXX_IMPL_THD_NO_CXX11_H
#define GRPCXX_IMPL_THD_NO_CXX11_H
#include <grpc/support/thd.h>
namespace grpc {
class thread {
public:
template <class T>
thread(void (T::*fptr)(), T *obj) {
func_ = new thread_function<T>(fptr, obj);
joined_ = false;
start();
}
template <class T, class U>
thread(void (T::*fptr)(U arg), T *obj, U arg) {
func_ = new thread_function_arg<T, U>(fptr, obj, arg);
joined_ = false;
start();
}
~thread() {
if (!joined_) std::terminate();
delete func_;
}
thread(thread &&other)
: func_(other.func_), thd_(other.thd_), joined_(other.joined_) {
other.joined_ = true;
other.func_ = NULL;
}
void join() {
gpr_thd_join(thd_);
joined_ = true;
}
private:
void start() {
gpr_thd_options options = gpr_thd_options_default();
gpr_thd_options_set_joinable(&options);
gpr_thd_new(&thd_, thread_func, (void *)func_, &options);
}
static void thread_func(void *arg) {
thread_function_base *func = (thread_function_base *)arg;
func->call();
}
class thread_function_base {
public:
virtual ~thread_function_base() {}
virtual void call() = 0;
};
template <class T>
class thread_function : public thread_function_base {
public:
thread_function(void (T::*fptr)(), T *obj) : fptr_(fptr), obj_(obj) {}
virtual void call() { (obj_->*fptr_)(); }
private:
void (T::*fptr_)();
T *obj_;
};
template <class T, class U>
class thread_function_arg : public thread_function_base {
public:
thread_function_arg(void (T::*fptr)(U arg), T *obj, U arg)
: fptr_(fptr), obj_(obj), arg_(arg) {}
virtual void call() { (obj_->*fptr_)(arg_); }
private:
void (T::*fptr_)(U arg);
T *obj_;
U arg_;
};
thread_function_base *func_;
gpr_thd_id thd_;
bool joined_;
// Disallow copy and assign.
thread(const thread &);
void operator=(const thread &);
};
} // namespace grpc
#endif // GRPCXX_IMPL_THD_NO_CXX11_H

@ -44,7 +44,7 @@ namespace grpc {
/// A ResourceQuota can be attached to a server (via ServerBuilder), or a client /// A ResourceQuota can be attached to a server (via ServerBuilder), or a client
/// channel (via ChannelArguments). gRPC will attempt to keep memory used by /// channel (via ChannelArguments). gRPC will attempt to keep memory used by
/// all attached entities below the ResourceQuota bound. /// all attached entities below the ResourceQuota bound.
class ResourceQuota GRPC_FINAL { class ResourceQuota final {
public: public:
explicit ResourceQuota(const grpc::string& name); explicit ResourceQuota(const grpc::string& name);
ResourceQuota(); ResourceQuota();

@ -34,8 +34,10 @@
#ifndef GRPCXX_SERVER_H #ifndef GRPCXX_SERVER_H
#define GRPCXX_SERVER_H #define GRPCXX_SERVER_H
#include <condition_variable>
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex>
#include <vector> #include <vector>
#include <grpc++/completion_queue.h> #include <grpc++/completion_queue.h>
@ -43,7 +45,6 @@
#include <grpc++/impl/codegen/grpc_library.h> #include <grpc++/impl/codegen/grpc_library.h>
#include <grpc++/impl/codegen/server_interface.h> #include <grpc++/impl/codegen/server_interface.h>
#include <grpc++/impl/rpc_service_method.h> #include <grpc++/impl/rpc_service_method.h>
#include <grpc++/impl/sync.h>
#include <grpc++/security/server_credentials.h> #include <grpc++/security/server_credentials.h>
#include <grpc++/support/channel_arguments.h> #include <grpc++/support/channel_arguments.h>
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
@ -64,7 +65,7 @@ class ThreadPoolInterface;
/// Models a gRPC server. /// Models a gRPC server.
/// ///
/// Servers are configured and started via \a grpc::ServerBuilder. /// Servers are configured and started via \a grpc::ServerBuilder.
class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen { class Server final : public ServerInterface, private GrpcLibraryCodegen {
public: public:
~Server(); ~Server();
@ -72,7 +73,7 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// ///
/// \warning The server must be either shutting down or some other thread must /// \warning The server must be either shutting down or some other thread must
/// call \a Shutdown for this function to ever return. /// call \a Shutdown for this function to ever return.
void Wait() GRPC_OVERRIDE; void Wait() override;
/// Global Callbacks /// Global Callbacks
/// ///
@ -143,12 +144,11 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// Register a service. This call does not take ownership of the service. /// Register a service. This call does not take ownership of the service.
/// The service must exist for the lifetime of the Server instance. /// The service must exist for the lifetime of the Server instance.
bool RegisterService(const grpc::string* host, bool RegisterService(const grpc::string* host, Service* service) override;
Service* service) GRPC_OVERRIDE;
/// Register a generic service. This call does not take ownership of the /// Register a generic service. This call does not take ownership of the
/// service. The service must exist for the lifetime of the Server instance. /// service. The service must exist for the lifetime of the Server instance.
void RegisterAsyncGenericService(AsyncGenericService* service) GRPC_OVERRIDE; void RegisterAsyncGenericService(AsyncGenericService* service) override;
/// Tries to bind \a server to the given \a addr. /// Tries to bind \a server to the given \a addr.
/// ///
@ -162,7 +162,7 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// ///
/// \warning It's an error to call this method on an already started server. /// \warning It's an error to call this method on an already started server.
int AddListeningPort(const grpc::string& addr, int AddListeningPort(const grpc::string& addr,
ServerCredentials* creds) GRPC_OVERRIDE; ServerCredentials* creds) override;
/// Start the server. /// Start the server.
/// ///
@ -172,17 +172,17 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// \param num_cqs How many completion queues does \a cqs hold. /// \param num_cqs How many completion queues does \a cqs hold.
/// ///
/// \return true on a successful shutdown. /// \return true on a successful shutdown.
bool Start(ServerCompletionQueue** cqs, size_t num_cqs) GRPC_OVERRIDE; bool Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) GRPC_OVERRIDE; void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override;
void ShutdownInternal(gpr_timespec deadline) GRPC_OVERRIDE; void ShutdownInternal(gpr_timespec deadline) override;
int max_receive_message_size() const GRPC_OVERRIDE { int max_receive_message_size() const override {
return max_receive_message_size_; return max_receive_message_size_;
}; };
grpc_server* server() GRPC_OVERRIDE { return server_; }; grpc_server* server() override { return server_; };
ServerInitializer* initializer(); ServerInitializer* initializer();
@ -198,12 +198,12 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_; std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_;
// Sever status // Sever status
grpc::mutex mu_; std::mutex mu_;
bool started_; bool started_;
bool shutdown_; bool shutdown_;
bool shutdown_notified_; // Was notify called on the shutdown_cv_ bool shutdown_notified_; // Was notify called on the shutdown_cv_
grpc::condition_variable shutdown_cv_; std::condition_variable shutdown_cv_;
std::shared_ptr<GlobalCallbacks> global_callbacks_; std::shared_ptr<GlobalCallbacks> global_callbacks_;

@ -47,7 +47,7 @@
namespace grpc { namespace grpc {
/// A sequence of bytes. /// A sequence of bytes.
class ByteBuffer GRPC_FINAL { class ByteBuffer final {
public: public:
/// Constuct an empty buffer. /// Constuct an empty buffer.
ByteBuffer() : buffer_(nullptr) {} ByteBuffer() : buffer_(nullptr) {}

@ -44,7 +44,7 @@ namespace grpc {
/// A slice represents a contiguous reference counted array of bytes. /// A slice represents a contiguous reference counted array of bytes.
/// It is cheap to take references to a slice, and it is cheap to create a /// It is cheap to take references to a slice, and it is cheap to create a
/// slice pointing to a subset of another slice. /// slice pointing to a subset of another slice.
class Slice GRPC_FINAL { class Slice final {
public: public:
/// Construct an empty slice. /// Construct an empty slice.
Slice(); Slice();

@ -322,7 +322,7 @@ void PrintHeaderClientMethod(Printer *printer, const Method *method,
printer->Print( printer->Print(
*vars, *vars,
"::grpc::Status $Method$(::grpc::ClientContext* context, " "::grpc::Status $Method$(::grpc::ClientContext* context, "
"const $Request$& request, $Response$* response) GRPC_OVERRIDE;\n"); "const $Request$& request, $Response$* response) override;\n");
printer->Print( printer->Print(
*vars, *vars,
"std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> " "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
@ -417,37 +417,34 @@ void PrintHeaderClientMethod(Printer *printer, const Method *method,
"::grpc::ClientAsyncResponseReader< $Response$>* " "::grpc::ClientAsyncResponseReader< $Response$>* "
"Async$Method$Raw(::grpc::ClientContext* context, " "Async$Method$Raw(::grpc::ClientContext* context, "
"const $Request$& request, " "const $Request$& request, "
"::grpc::CompletionQueue* cq) GRPC_OVERRIDE;\n"); "::grpc::CompletionQueue* cq) override;\n");
} else if (method->ClientOnlyStreaming()) { } else if (method->ClientOnlyStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientWriter< $Request$>* $Method$Raw(" "::grpc::ClientWriter< $Request$>* $Method$Raw("
"::grpc::ClientContext* context, $Response$* response) " "::grpc::ClientContext* context, $Response$* response) "
"GRPC_OVERRIDE;\n"); "override;\n");
printer->Print( printer->Print(*vars,
*vars, "::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw("
"::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw(" "::grpc::ClientContext* context, $Response$* response, "
"::grpc::ClientContext* context, $Response$* response, " "::grpc::CompletionQueue* cq, void* tag) override;\n");
"::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
} else if (method->ServerOnlyStreaming()) { } else if (method->ServerOnlyStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientReader< $Response$>* $Method$Raw(" "::grpc::ClientReader< $Response$>* $Method$Raw("
"::grpc::ClientContext* context, const $Request$& request)" "::grpc::ClientContext* context, const $Request$& request)"
" GRPC_OVERRIDE;\n"); " override;\n");
printer->Print( printer->Print(
*vars, *vars,
"::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw(" "::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw("
"::grpc::ClientContext* context, const $Request$& request, " "::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n"); "::grpc::CompletionQueue* cq, void* tag) override;\n");
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print( printer->Print(*vars,
*vars, "::grpc::ClientReaderWriter< $Request$, $Response$>* "
"::grpc::ClientReaderWriter< $Request$, $Response$>* " "$Method$Raw(::grpc::ClientContext* context) override;\n");
"$Method$Raw(::grpc::ClientContext* context) GRPC_OVERRIDE;\n"); printer->Print(*vars,
printer->Print( "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
*vars, "Async$Method$Raw(::grpc::ClientContext* context, "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* " "::grpc::CompletionQueue* cq, void* tag) override;\n");
"Async$Method$Raw(::grpc::ClientContext* context, "
"::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
} }
} }
} }
@ -509,7 +506,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
" ::grpc::Service::MarkMethodAsync($Idx$);\n" " ::grpc::Service::MarkMethodAsync($Idx$);\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithAsyncMethod_$Method$() GRPC_OVERRIDE {\n" "~WithAsyncMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
if (method->NoStreaming()) { if (method->NoStreaming()) {
@ -518,7 +515,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -540,7 +537,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReader< $Request$>* reader, " "::grpc::ServerReader< $Request$>* reader, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -561,7 +558,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE " "::grpc::ServerWriter< $Response$>* writer) final override "
"{\n" "{\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -585,7 +582,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReaderWriter< $Response$, $Request$>* stream) " "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
"GRPC_FINAL GRPC_OVERRIDE {\n" "final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -632,7 +629,7 @@ void PrintHeaderServerMethodStreamedUnary(
"std::placeholders::_2)));\n" "std::placeholders::_2)));\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithStreamedUnaryMethod_$Method$() GRPC_OVERRIDE {\n" "~WithStreamedUnaryMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
printer->Print( printer->Print(
@ -640,7 +637,7 @@ void PrintHeaderServerMethodStreamedUnary(
"// disable regular version of this method\n" "// disable regular version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -683,7 +680,7 @@ void PrintHeaderServerMethodSplitStreaming(
"std::placeholders::_2)));\n" "std::placeholders::_2)));\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithSplitStreamingMethod_$Method$() GRPC_OVERRIDE {\n" "~WithSplitStreamingMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
printer->Print( printer->Print(
@ -691,7 +688,7 @@ void PrintHeaderServerMethodSplitStreaming(
"// disable regular version of this method\n" "// disable regular version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE " "::grpc::ServerWriter< $Response$>* writer) final override "
"{\n" "{\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -727,7 +724,7 @@ void PrintHeaderServerMethodGeneric(
" ::grpc::Service::MarkMethodGeneric($Idx$);\n" " ::grpc::Service::MarkMethodGeneric($Idx$);\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithGenericMethod_$Method$() GRPC_OVERRIDE {\n" "~WithGenericMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
if (method->NoStreaming()) { if (method->NoStreaming()) {
@ -736,7 +733,7 @@ void PrintHeaderServerMethodGeneric(
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -747,7 +744,7 @@ void PrintHeaderServerMethodGeneric(
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReader< $Request$>* reader, " "::grpc::ServerReader< $Request$>* reader, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -757,7 +754,7 @@ void PrintHeaderServerMethodGeneric(
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE " "::grpc::ServerWriter< $Response$>* writer) final override "
"{\n" "{\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -769,7 +766,7 @@ void PrintHeaderServerMethodGeneric(
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReaderWriter< $Response$, $Request$>* stream) " "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
"GRPC_FINAL GRPC_OVERRIDE {\n" "final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -784,7 +781,7 @@ void PrintHeaderService(Printer *printer, const Service *service,
printer->Print(service->GetLeadingComments().c_str()); printer->Print(service->GetLeadingComments().c_str());
printer->Print(*vars, printer->Print(*vars,
"class $Service$ GRPC_FINAL {\n" "class $Service$ final {\n"
" public:\n"); " public:\n");
printer->Indent(); printer->Indent();
@ -810,7 +807,7 @@ void PrintHeaderService(Printer *printer, const Service *service,
printer->Outdent(); printer->Outdent();
printer->Print("};\n"); printer->Print("};\n");
printer->Print( printer->Print(
"class Stub GRPC_FINAL : public StubInterface" "class Stub final : public StubInterface"
" {\n public:\n"); " {\n public:\n");
printer->Indent(); printer->Indent();
printer->Print( printer->Print(

@ -106,11 +106,11 @@ grpc_connectivity_state Channel::GetState(bool try_to_connect) {
} }
namespace { namespace {
class TagSaver GRPC_FINAL : public CompletionQueueTag { class TagSaver final : public CompletionQueueTag {
public: public:
explicit TagSaver(void* tag) : tag_(tag) {} explicit TagSaver(void* tag) : tag_(tag) {}
~TagSaver() GRPC_OVERRIDE {} ~TagSaver() override {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
*tag = tag_; *tag = tag_;
delete this; delete this;
return true; return true;

@ -45,12 +45,12 @@
namespace grpc { namespace grpc {
class DefaultGlobalClientCallbacks GRPC_FINAL class DefaultGlobalClientCallbacks final
: public ClientContext::GlobalCallbacks { : public ClientContext::GlobalCallbacks {
public: public:
~DefaultGlobalClientCallbacks() GRPC_OVERRIDE {} ~DefaultGlobalClientCallbacks() override {}
void DefaultConstructor(ClientContext* context) GRPC_OVERRIDE {} void DefaultConstructor(ClientContext* context) override {}
void Destructor(ClientContext* context) GRPC_OVERRIDE {} void Destructor(ClientContext* context) override {}
}; };
static DefaultGlobalClientCallbacks g_default_client_callbacks; static DefaultGlobalClientCallbacks g_default_client_callbacks;
@ -93,7 +93,7 @@ void ClientContext::AddMetadata(const grpc::string& meta_key,
void ClientContext::set_call(grpc_call* call, void ClientContext::set_call(grpc_call* call,
const std::shared_ptr<Channel>& channel) { const std::shared_ptr<Channel>& channel) {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
GPR_ASSERT(call_ == nullptr); GPR_ASSERT(call_ == nullptr);
call_ = call; call_ = call;
channel_ = channel; channel_ = channel;
@ -119,7 +119,7 @@ void ClientContext::set_compression_algorithm(
} }
void ClientContext::TryCancel() { void ClientContext::TryCancel() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (call_) { if (call_) {
grpc_call_cancel(call_, nullptr); grpc_call_cancel(call_, nullptr);
} else { } else {

@ -40,12 +40,12 @@
namespace grpc { namespace grpc {
class CronetChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials { class CronetChannelCredentialsImpl final : public ChannelCredentials {
public: public:
CronetChannelCredentialsImpl(void* engine) : engine_(engine) {} CronetChannelCredentialsImpl(void* engine) : engine_(engine) {}
std::shared_ptr<grpc::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE { const string& target, const grpc::ChannelArguments& args) override {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return CreateChannelInternal( return CreateChannelInternal(
@ -53,9 +53,7 @@ class CronetChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials {
&channel_args, nullptr)); &channel_args, nullptr));
} }
SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
return nullptr;
}
private: private:
void* engine_; void* engine_;

@ -43,10 +43,10 @@
namespace grpc { namespace grpc {
namespace { namespace {
class InsecureChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials { class InsecureChannelCredentialsImpl final : public ChannelCredentials {
public: public:
std::shared_ptr<grpc::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE { const string& target, const grpc::ChannelArguments& args) override {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return CreateChannelInternal( return CreateChannelInternal(
@ -54,9 +54,7 @@ class InsecureChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials {
grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr)); grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr));
} }
SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
return nullptr;
}
}; };
} // namespace } // namespace

@ -43,34 +43,34 @@
namespace grpc { namespace grpc {
class SecureChannelCredentials GRPC_FINAL : public ChannelCredentials { class SecureChannelCredentials final : public ChannelCredentials {
public: public:
explicit SecureChannelCredentials(grpc_channel_credentials* c_creds); explicit SecureChannelCredentials(grpc_channel_credentials* c_creds);
~SecureChannelCredentials() { grpc_channel_credentials_release(c_creds_); } ~SecureChannelCredentials() { grpc_channel_credentials_release(c_creds_); }
grpc_channel_credentials* GetRawCreds() { return c_creds_; } grpc_channel_credentials* GetRawCreds() { return c_creds_; }
std::shared_ptr<grpc::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE; const string& target, const grpc::ChannelArguments& args) override;
SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; } SecureChannelCredentials* AsSecureCredentials() override { return this; }
private: private:
grpc_channel_credentials* const c_creds_; grpc_channel_credentials* const c_creds_;
}; };
class SecureCallCredentials GRPC_FINAL : public CallCredentials { class SecureCallCredentials final : public CallCredentials {
public: public:
explicit SecureCallCredentials(grpc_call_credentials* c_creds); explicit SecureCallCredentials(grpc_call_credentials* c_creds);
~SecureCallCredentials() { grpc_call_credentials_release(c_creds_); } ~SecureCallCredentials() { grpc_call_credentials_release(c_creds_); }
grpc_call_credentials* GetRawCreds() { return c_creds_; } grpc_call_credentials* GetRawCreds() { return c_creds_; }
bool ApplyToCall(grpc_call* call) GRPC_OVERRIDE; bool ApplyToCall(grpc_call* call) override;
SecureCallCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; } SecureCallCredentials* AsSecureCredentials() override { return this; }
private: private:
grpc_call_credentials* const c_creds_; grpc_call_credentials* const c_creds_;
}; };
class MetadataCredentialsPluginWrapper GRPC_FINAL { class MetadataCredentialsPluginWrapper final {
public: public:
static void Destroy(void* wrapper); static void Destroy(void* wrapper);
static void GetMetadata(void* wrapper, grpc_auth_metadata_context context, static void GetMetadata(void* wrapper, grpc_auth_metadata_context context,

@ -268,7 +268,7 @@ namespace internal {
// Members of this class correspond to the members of the C // Members of this class correspond to the members of the C
// grpc_channel_filter struct. // grpc_channel_filter struct.
template <typename ChannelDataType, typename CallDataType> template <typename ChannelDataType, typename CallDataType>
class ChannelFilter GRPC_FINAL { class ChannelFilter final {
public: public:
static const size_t channel_data_size = sizeof(ChannelDataType); static const size_t channel_data_size = sizeof(ChannelDataType);

@ -40,30 +40,29 @@ struct grpc_auth_context;
namespace grpc { namespace grpc {
class SecureAuthContext GRPC_FINAL : public AuthContext { class SecureAuthContext final : public AuthContext {
public: public:
SecureAuthContext(grpc_auth_context* ctx, bool take_ownership); SecureAuthContext(grpc_auth_context* ctx, bool take_ownership);
~SecureAuthContext() GRPC_OVERRIDE; ~SecureAuthContext() override;
bool IsPeerAuthenticated() const GRPC_OVERRIDE; bool IsPeerAuthenticated() const override;
std::vector<grpc::string_ref> GetPeerIdentity() const GRPC_OVERRIDE; std::vector<grpc::string_ref> GetPeerIdentity() const override;
grpc::string GetPeerIdentityPropertyName() const GRPC_OVERRIDE; grpc::string GetPeerIdentityPropertyName() const override;
std::vector<grpc::string_ref> FindPropertyValues( std::vector<grpc::string_ref> FindPropertyValues(
const grpc::string& name) const GRPC_OVERRIDE; const grpc::string& name) const override;
AuthPropertyIterator begin() const GRPC_OVERRIDE; AuthPropertyIterator begin() const override;
AuthPropertyIterator end() const GRPC_OVERRIDE; AuthPropertyIterator end() const override;
void AddProperty(const grpc::string& key, void AddProperty(const grpc::string& key,
const grpc::string_ref& value) GRPC_OVERRIDE; const grpc::string_ref& value) override;
virtual bool SetPeerIdentityPropertyName(const grpc::string& name) virtual bool SetPeerIdentityPropertyName(const grpc::string& name) override;
GRPC_OVERRIDE;
private: private:
grpc_auth_context* ctx_; grpc_auth_context* ctx_;

@ -42,7 +42,7 @@
namespace grpc { namespace grpc {
class ProtoServerReflection GRPC_FINAL class ProtoServerReflection final
: public reflection::v1alpha::ServerReflection::Service { : public reflection::v1alpha::ServerReflection::Service {
public: public:
ProtoServerReflection(); ProtoServerReflection();
@ -56,7 +56,7 @@ class ProtoServerReflection GRPC_FINAL
ServerContext* context, ServerContext* context,
ServerReaderWriter<reflection::v1alpha::ServerReflectionResponse, ServerReaderWriter<reflection::v1alpha::ServerReflectionResponse,
reflection::v1alpha::ServerReflectionRequest>* stream) reflection::v1alpha::ServerReflectionRequest>* stream)
GRPC_OVERRIDE; override;
private: private:
Status ListService(ServerContext* context, Status ListService(ServerContext* context,

@ -31,16 +31,16 @@
* *
*/ */
#include <grpc++/impl/sync.h> #include <mutex>
#include <grpc++/impl/thd.h> #include <thread>
#include "src/cpp/server/dynamic_thread_pool.h" #include "src/cpp/server/dynamic_thread_pool.h"
namespace grpc { namespace grpc {
DynamicThreadPool::DynamicThread::DynamicThread(DynamicThreadPool* pool) DynamicThreadPool::DynamicThread::DynamicThread(DynamicThreadPool* pool)
: pool_(pool), : pool_(pool),
thd_(new grpc::thread(&DynamicThreadPool::DynamicThread::ThreadFunc, thd_(new std::thread(&DynamicThreadPool::DynamicThread::ThreadFunc,
this)) {} this)) {}
DynamicThreadPool::DynamicThread::~DynamicThread() { DynamicThreadPool::DynamicThread::~DynamicThread() {
thd_->join(); thd_->join();
thd_.reset(); thd_.reset();
@ -49,7 +49,7 @@ DynamicThreadPool::DynamicThread::~DynamicThread() {
void DynamicThreadPool::DynamicThread::ThreadFunc() { void DynamicThreadPool::DynamicThread::ThreadFunc() {
pool_->ThreadFunc(); pool_->ThreadFunc();
// Now that we have killed ourselves, we should reduce the thread count // Now that we have killed ourselves, we should reduce the thread count
grpc::unique_lock<grpc::mutex> lock(pool_->mu_); std::unique_lock<std::mutex> lock(pool_->mu_);
pool_->nthreads_--; pool_->nthreads_--;
// Move ourselves to dead list // Move ourselves to dead list
pool_->dead_threads_.push_back(this); pool_->dead_threads_.push_back(this);
@ -62,7 +62,7 @@ void DynamicThreadPool::DynamicThread::ThreadFunc() {
void DynamicThreadPool::ThreadFunc() { void DynamicThreadPool::ThreadFunc() {
for (;;) { for (;;) {
// Wait until work is available or we are shutting down. // Wait until work is available or we are shutting down.
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (!shutdown_ && callbacks_.empty()) { if (!shutdown_ && callbacks_.empty()) {
// If there are too many threads waiting, then quit this thread // If there are too many threads waiting, then quit this thread
if (threads_waiting_ >= reserve_threads_) { if (threads_waiting_ >= reserve_threads_) {
@ -91,7 +91,7 @@ DynamicThreadPool::DynamicThreadPool(int reserve_threads)
nthreads_(0), nthreads_(0),
threads_waiting_(0) { threads_waiting_(0) {
for (int i = 0; i < reserve_threads_; i++) { for (int i = 0; i < reserve_threads_; i++) {
grpc::lock_guard<grpc::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
nthreads_++; nthreads_++;
new DynamicThread(this); new DynamicThread(this);
} }
@ -104,7 +104,7 @@ void DynamicThreadPool::ReapThreads(std::list<DynamicThread*>* tlist) {
} }
DynamicThreadPool::~DynamicThreadPool() { DynamicThreadPool::~DynamicThreadPool() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
shutdown_ = true; shutdown_ = true;
cv_.notify_all(); cv_.notify_all();
while (nthreads_ != 0) { while (nthreads_ != 0) {
@ -114,7 +114,7 @@ DynamicThreadPool::~DynamicThreadPool() {
} }
void DynamicThreadPool::Add(const std::function<void()>& callback) { void DynamicThreadPool::Add(const std::function<void()>& callback) {
grpc::lock_guard<grpc::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
// Add works to the callbacks list // Add works to the callbacks list
callbacks_.push(callback); callbacks_.push(callback);
// Increase pool size or notify as needed // Increase pool size or notify as needed

@ -34,24 +34,25 @@
#ifndef GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H #ifndef GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H
#define GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H #define GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H
#include <condition_variable>
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex>
#include <queue> #include <queue>
#include <thread>
#include <grpc++/impl/sync.h>
#include <grpc++/impl/thd.h>
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
#include "src/cpp/server/thread_pool_interface.h" #include "src/cpp/server/thread_pool_interface.h"
namespace grpc { namespace grpc {
class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface { class DynamicThreadPool final : public ThreadPoolInterface {
public: public:
explicit DynamicThreadPool(int reserve_threads); explicit DynamicThreadPool(int reserve_threads);
~DynamicThreadPool(); ~DynamicThreadPool();
void Add(const std::function<void()>& callback) GRPC_OVERRIDE; void Add(const std::function<void()>& callback) override;
private: private:
class DynamicThread { class DynamicThread {
@ -61,12 +62,12 @@ class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface {
private: private:
DynamicThreadPool* pool_; DynamicThreadPool* pool_;
std::unique_ptr<grpc::thread> thd_; std::unique_ptr<std::thread> thd_;
void ThreadFunc(); void ThreadFunc();
}; };
grpc::mutex mu_; std::mutex mu_;
grpc::condition_variable cv_; std::condition_variable cv_;
grpc::condition_variable shutdown_cv_; std::condition_variable shutdown_cv_;
bool shutdown_; bool shutdown_;
std::queue<std::function<void()>> callbacks_; std::queue<std::function<void()>> callbacks_;
int reserve_threads_; int reserve_threads_;

@ -38,14 +38,13 @@
namespace grpc { namespace grpc {
namespace { namespace {
class InsecureServerCredentialsImpl GRPC_FINAL : public ServerCredentials { class InsecureServerCredentialsImpl final : public ServerCredentials {
public: public:
int AddPortToServer(const grpc::string& addr, int AddPortToServer(const grpc::string& addr, grpc_server* server) override {
grpc_server* server) GRPC_OVERRIDE {
return grpc_server_add_insecure_http2_port(server, addr.c_str()); return grpc_server_add_insecure_http2_port(server, addr.c_str());
} }
void SetAuthMetadataProcessor( void SetAuthMetadataProcessor(
const std::shared_ptr<AuthMetadataProcessor>& processor) GRPC_OVERRIDE { const std::shared_ptr<AuthMetadataProcessor>& processor) override {
(void)processor; (void)processor;
GPR_ASSERT(0); // Should not be called on InsecureServerCredentials. GPR_ASSERT(0); // Should not be called on InsecureServerCredentials.
} }

@ -44,7 +44,7 @@
namespace grpc { namespace grpc {
class AuthMetadataProcessorAyncWrapper GRPC_FINAL { class AuthMetadataProcessorAyncWrapper final {
public: public:
static void Destroy(void* wrapper); static void Destroy(void* wrapper);
@ -64,19 +64,18 @@ class AuthMetadataProcessorAyncWrapper GRPC_FINAL {
std::shared_ptr<AuthMetadataProcessor> processor_; std::shared_ptr<AuthMetadataProcessor> processor_;
}; };
class SecureServerCredentials GRPC_FINAL : public ServerCredentials { class SecureServerCredentials final : public ServerCredentials {
public: public:
explicit SecureServerCredentials(grpc_server_credentials* creds) explicit SecureServerCredentials(grpc_server_credentials* creds)
: creds_(creds) {} : creds_(creds) {}
~SecureServerCredentials() GRPC_OVERRIDE { ~SecureServerCredentials() override {
grpc_server_credentials_release(creds_); grpc_server_credentials_release(creds_);
} }
int AddPortToServer(const grpc::string& addr, int AddPortToServer(const grpc::string& addr, grpc_server* server) override;
grpc_server* server) GRPC_OVERRIDE;
void SetAuthMetadataProcessor( void SetAuthMetadataProcessor(
const std::shared_ptr<AuthMetadataProcessor>& processor) GRPC_OVERRIDE; const std::shared_ptr<AuthMetadataProcessor>& processor) override;
private: private:
grpc_server_credentials* creds_; grpc_server_credentials* creds_;

@ -55,11 +55,11 @@
namespace grpc { namespace grpc {
class DefaultGlobalCallbacks GRPC_FINAL : public Server::GlobalCallbacks { class DefaultGlobalCallbacks final : public Server::GlobalCallbacks {
public: public:
~DefaultGlobalCallbacks() GRPC_OVERRIDE {} ~DefaultGlobalCallbacks() override {}
void PreSynchronousRequest(ServerContext* context) GRPC_OVERRIDE {} void PreSynchronousRequest(ServerContext* context) override {}
void PostSynchronousRequest(ServerContext* context) GRPC_OVERRIDE {} void PostSynchronousRequest(ServerContext* context) override {}
}; };
static std::shared_ptr<Server::GlobalCallbacks> g_callbacks = nullptr; static std::shared_ptr<Server::GlobalCallbacks> g_callbacks = nullptr;
@ -79,7 +79,7 @@ class Server::UnimplementedAsyncRequestContext {
GenericServerAsyncReaderWriter generic_stream_; GenericServerAsyncReaderWriter generic_stream_;
}; };
class Server::UnimplementedAsyncRequest GRPC_FINAL class Server::UnimplementedAsyncRequest final
: public UnimplementedAsyncRequestContext, : public UnimplementedAsyncRequestContext,
public GenericAsyncRequest { public GenericAsyncRequest {
public: public:
@ -89,7 +89,7 @@ class Server::UnimplementedAsyncRequest GRPC_FINAL
server_(server), server_(server),
cq_(cq) {} cq_(cq) {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
ServerContext* context() { return &server_context_; } ServerContext* context() { return &server_context_; }
GenericServerAsyncReaderWriter* stream() { return &generic_stream_; } GenericServerAsyncReaderWriter* stream() { return &generic_stream_; }
@ -101,13 +101,13 @@ class Server::UnimplementedAsyncRequest GRPC_FINAL
typedef SneakyCallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> typedef SneakyCallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus>
UnimplementedAsyncResponseOp; UnimplementedAsyncResponseOp;
class Server::UnimplementedAsyncResponse GRPC_FINAL class Server::UnimplementedAsyncResponse final
: public UnimplementedAsyncResponseOp { : public UnimplementedAsyncResponseOp {
public: public:
UnimplementedAsyncResponse(UnimplementedAsyncRequest* request); UnimplementedAsyncResponse(UnimplementedAsyncRequest* request);
~UnimplementedAsyncResponse() { delete request_; } ~UnimplementedAsyncResponse() { delete request_; }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
bool r = UnimplementedAsyncResponseOp::FinalizeResult(tag, status); bool r = UnimplementedAsyncResponseOp::FinalizeResult(tag, status);
delete this; delete this;
return r; return r;
@ -122,7 +122,7 @@ class ShutdownTag : public CompletionQueueTag {
bool FinalizeResult(void** tag, bool* status) { return false; } bool FinalizeResult(void** tag, bool* status) { return false; }
}; };
class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { class Server::SyncRequest final : public CompletionQueueTag {
public: public:
SyncRequest(RpcServiceMethod* method, void* tag) SyncRequest(RpcServiceMethod* method, void* tag)
: method_(method), : method_(method),
@ -170,7 +170,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
} }
} }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
if (!*status) { if (!*status) {
grpc_completion_queue_destroy(cq_); grpc_completion_queue_destroy(cq_);
} }
@ -182,7 +182,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
return true; return true;
} }
class CallData GRPC_FINAL { class CallData final {
public: public:
explicit CallData(Server* server, SyncRequest* mrd) explicit CallData(Server* server, SyncRequest* mrd)
: cq_(mrd->cq_), : cq_(mrd->cq_),
@ -255,7 +255,7 @@ class Server::SyncRequestThreadManager : public ThreadManager {
cq_timeout_msec_(cq_timeout_msec), cq_timeout_msec_(cq_timeout_msec),
global_callbacks_(global_callbacks) {} global_callbacks_(global_callbacks) {}
WorkStatus PollForWork(void** tag, bool* ok) GRPC_OVERRIDE { WorkStatus PollForWork(void** tag, bool* ok) override {
*tag = nullptr; *tag = nullptr;
gpr_timespec deadline = gpr_timespec deadline =
gpr_time_from_millis(cq_timeout_msec_, GPR_TIMESPAN); gpr_time_from_millis(cq_timeout_msec_, GPR_TIMESPAN);
@ -272,7 +272,7 @@ class Server::SyncRequestThreadManager : public ThreadManager {
GPR_UNREACHABLE_CODE(return TIMEOUT); GPR_UNREACHABLE_CODE(return TIMEOUT);
} }
void DoWork(void* tag, bool ok) GRPC_OVERRIDE { void DoWork(void* tag, bool ok) override {
SyncRequest* sync_req = static_cast<SyncRequest*>(tag); SyncRequest* sync_req = static_cast<SyncRequest*>(tag);
if (!sync_req) { if (!sync_req) {
@ -379,7 +379,7 @@ Server::Server(
Server::~Server() { Server::~Server() {
{ {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (started_ && !shutdown_) { if (started_ && !shutdown_) {
lock.unlock(); lock.unlock();
Shutdown(); Shutdown();
@ -501,7 +501,7 @@ bool Server::Start(ServerCompletionQueue** cqs, size_t num_cqs) {
} }
void Server::ShutdownInternal(gpr_timespec deadline) { void Server::ShutdownInternal(gpr_timespec deadline) {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (started_ && !shutdown_) { if (started_ && !shutdown_) {
shutdown_ = true; shutdown_ = true;
@ -549,7 +549,7 @@ void Server::ShutdownInternal(gpr_timespec deadline) {
} }
void Server::Wait() { void Server::Wait() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
while (started_ && !shutdown_notified_) { while (started_ && !shutdown_notified_) {
shutdown_cv_.wait(lock); shutdown_cv_.wait(lock);
} }

@ -33,9 +33,10 @@
#include <grpc++/server_context.h> #include <grpc++/server_context.h>
#include <mutex>
#include <grpc++/completion_queue.h> #include <grpc++/completion_queue.h>
#include <grpc++/impl/call.h> #include <grpc++/impl/call.h>
#include <grpc++/impl/sync.h>
#include <grpc++/support/time.h> #include <grpc++/support/time.h>
#include <grpc/compression.h> #include <grpc/compression.h>
#include <grpc/grpc.h> #include <grpc/grpc.h>
@ -48,7 +49,7 @@ namespace grpc {
// CompletionOp // CompletionOp
class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface { class ServerContext::CompletionOp final : public CallOpSetInterface {
public: public:
// initial refs: one in the server context, one in the cq // initial refs: one in the server context, one in the cq
CompletionOp() CompletionOp()
@ -58,8 +59,8 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
finalized_(false), finalized_(false),
cancelled_(0) {} cancelled_(0) {}
void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE; void FillOps(grpc_op* ops, size_t* nops) override;
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
bool CheckCancelled(CompletionQueue* cq) { bool CheckCancelled(CompletionQueue* cq) {
cq->TryPluck(this); cq->TryPluck(this);
@ -76,20 +77,20 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
private: private:
bool CheckCancelledNoPluck() { bool CheckCancelledNoPluck() {
grpc::lock_guard<grpc::mutex> g(mu_); std::lock_guard<std::mutex> g(mu_);
return finalized_ ? (cancelled_ != 0) : false; return finalized_ ? (cancelled_ != 0) : false;
} }
bool has_tag_; bool has_tag_;
void* tag_; void* tag_;
grpc::mutex mu_; std::mutex mu_;
int refs_; int refs_;
bool finalized_; bool finalized_;
int cancelled_; int cancelled_;
}; };
void ServerContext::CompletionOp::Unref() { void ServerContext::CompletionOp::Unref() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (--refs_ == 0) { if (--refs_ == 0) {
lock.unlock(); lock.unlock();
delete this; delete this;
@ -105,7 +106,7 @@ void ServerContext::CompletionOp::FillOps(grpc_op* ops, size_t* nops) {
} }
bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) { bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
finalized_ = true; finalized_ = true;
bool ret = false; bool ret = false;
if (has_tag_) { if (has_tag_) {

@ -31,12 +31,13 @@
* *
*/ */
#include <grpc++/impl/sync.h> #include "src/cpp/thread_manager/thread_manager.h"
#include <grpc++/impl/thd.h>
#include <grpc/support/log.h>
#include <climits> #include <climits>
#include <mutex>
#include <thread>
#include "src/cpp/thread_manager/thread_manager.h" #include <grpc/support/log.h>
namespace grpc { namespace grpc {
@ -59,7 +60,7 @@ ThreadManager::ThreadManager(int min_pollers, int max_pollers)
ThreadManager::~ThreadManager() { ThreadManager::~ThreadManager() {
{ {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
GPR_ASSERT(num_threads_ == 0); GPR_ASSERT(num_threads_ == 0);
} }
@ -67,29 +68,29 @@ ThreadManager::~ThreadManager() {
} }
void ThreadManager::Wait() { void ThreadManager::Wait() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
while (num_threads_ != 0) { while (num_threads_ != 0) {
shutdown_cv_.wait(lock); shutdown_cv_.wait(lock);
} }
} }
void ThreadManager::Shutdown() { void ThreadManager::Shutdown() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
shutdown_ = true; shutdown_ = true;
} }
bool ThreadManager::IsShutdown() { bool ThreadManager::IsShutdown() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
return shutdown_; return shutdown_;
} }
void ThreadManager::MarkAsCompleted(WorkerThread* thd) { void ThreadManager::MarkAsCompleted(WorkerThread* thd) {
{ {
std::unique_lock<grpc::mutex> list_lock(list_mu_); std::unique_lock<std::mutex> list_lock(list_mu_);
completed_threads_.push_back(thd); completed_threads_.push_back(thd);
} }
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
num_threads_--; num_threads_--;
if (num_threads_ == 0) { if (num_threads_ == 0) {
shutdown_cv_.notify_one(); shutdown_cv_.notify_one();
@ -97,7 +98,7 @@ void ThreadManager::MarkAsCompleted(WorkerThread* thd) {
} }
void ThreadManager::CleanupCompletedThreads() { void ThreadManager::CleanupCompletedThreads() {
std::unique_lock<grpc::mutex> lock(list_mu_); std::unique_lock<std::mutex> lock(list_mu_);
for (auto thd = completed_threads_.begin(); thd != completed_threads_.end(); for (auto thd = completed_threads_.begin(); thd != completed_threads_.end();
thd = completed_threads_.erase(thd)) { thd = completed_threads_.erase(thd)) {
delete *thd; delete *thd;
@ -114,7 +115,7 @@ void ThreadManager::Initialize() {
// less than max threshold (i.e max_pollers_) and the total number of threads is // less than max threshold (i.e max_pollers_) and the total number of threads is
// below the maximum threshold, we can let the current thread continue as poller // below the maximum threshold, we can let the current thread continue as poller
bool ThreadManager::MaybeContinueAsPoller() { bool ThreadManager::MaybeContinueAsPoller() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (shutdown_ || num_pollers_ > max_pollers_) { if (shutdown_ || num_pollers_ > max_pollers_) {
return false; return false;
} }
@ -127,7 +128,7 @@ bool ThreadManager::MaybeContinueAsPoller() {
// threads currently blocked in PollForWork()) is below the threshold (i.e // threads currently blocked in PollForWork()) is below the threshold (i.e
// min_pollers_) and the total number of threads is below the maximum threshold // min_pollers_) and the total number of threads is below the maximum threshold
void ThreadManager::MaybeCreatePoller() { void ThreadManager::MaybeCreatePoller() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (!shutdown_ && num_pollers_ < min_pollers_) { if (!shutdown_ && num_pollers_ < min_pollers_) {
num_pollers_++; num_pollers_++;
num_threads_++; num_threads_++;
@ -156,7 +157,7 @@ void ThreadManager::MainWorkLoop() {
WorkStatus work_status = PollForWork(&tag, &ok); WorkStatus work_status = PollForWork(&tag, &ok);
{ {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
num_pollers_--; num_pollers_--;
if (work_status == TIMEOUT && num_pollers_ > min_pollers_) { if (work_status == TIMEOUT && num_pollers_ > min_pollers_) {

@ -34,11 +34,12 @@
#ifndef GRPC_INTERNAL_CPP_THREAD_MANAGER_H #ifndef GRPC_INTERNAL_CPP_THREAD_MANAGER_H
#define GRPC_INTERNAL_CPP_THREAD_MANAGER_H #define GRPC_INTERNAL_CPP_THREAD_MANAGER_H
#include <condition_variable>
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex>
#include <thread>
#include <grpc++/impl/sync.h>
#include <grpc++/impl/thd.h>
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
namespace grpc { namespace grpc {
@ -115,7 +116,7 @@ class ThreadManager {
void Run(); void Run();
ThreadManager* thd_mgr_; ThreadManager* thd_mgr_;
grpc::thread thd_; std::thread thd_;
}; };
// The main funtion in ThreadManager // The main funtion in ThreadManager
@ -134,10 +135,10 @@ class ThreadManager {
// Protects shutdown_, num_pollers_ and num_threads_ // Protects shutdown_, num_pollers_ and num_threads_
// TODO: sreek - Change num_pollers and num_threads_ to atomics // TODO: sreek - Change num_pollers and num_threads_ to atomics
grpc::mutex mu_; std::mutex mu_;
bool shutdown_; bool shutdown_;
grpc::condition_variable shutdown_cv_; std::condition_variable shutdown_cv_;
// Number of threads doing polling // Number of threads doing polling
int num_pollers_; int num_pollers_;
@ -150,7 +151,7 @@ class ThreadManager {
// currently polling i.e num_pollers_) // currently polling i.e num_pollers_)
int num_threads_; int num_threads_;
grpc::mutex list_mu_; std::mutex list_mu_;
std::list<WorkerThread*> completed_threads_; std::list<WorkerThread*> completed_threads_;
}; };

@ -32,9 +32,6 @@
*/ */
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
#ifndef GRPC_CXX0X_NO_CHRONO
#include <grpc++/support/time.h> #include <grpc++/support/time.h>
#include <grpc/support/time.h> #include <grpc/support/time.h>
@ -91,5 +88,3 @@ system_clock::time_point Timespec2Timepoint(gpr_timespec t) {
} }
} // namespace grpc } // namespace grpc
#endif // !GRPC_CXX0X_NO_CHRONO

@ -67,7 +67,7 @@ namespace testing {
// ServiceA detached comment 2 // ServiceA detached comment 2
// //
// ServiceA leading comment 1 // ServiceA leading comment 1
class ServiceA GRPC_FINAL { class ServiceA final {
public: public:
class StubInterface { class StubInterface {
public: public:
@ -94,10 +94,10 @@ class ServiceA GRPC_FINAL {
virtual ::grpc::ClientWriterInterface< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) = 0; virtual ::grpc::ClientWriterInterface< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) = 0;
virtual ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
}; };
class Stub GRPC_FINAL : public StubInterface { class Stub final : public StubInterface {
public: public:
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
::grpc::Status MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) GRPC_OVERRIDE; ::grpc::Status MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) override;
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq)); return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq));
} }
@ -110,9 +110,9 @@ class ServiceA GRPC_FINAL {
private: private:
std::shared_ptr< ::grpc::ChannelInterface> channel_; std::shared_ptr< ::grpc::ChannelInterface> channel_;
::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) GRPC_OVERRIDE; ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientWriter< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) GRPC_OVERRIDE; ::grpc::ClientWriter< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) override;
::grpc::ClientAsyncWriter< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE; ::grpc::ClientAsyncWriter< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) override;
const ::grpc::RpcMethod rpcmethod_MethodA1_; const ::grpc::RpcMethod rpcmethod_MethodA1_;
const ::grpc::RpcMethod rpcmethod_MethodA2_; const ::grpc::RpcMethod rpcmethod_MethodA2_;
}; };
@ -140,11 +140,11 @@ class ServiceA GRPC_FINAL {
WithAsyncMethod_MethodA1() { WithAsyncMethod_MethodA1() {
::grpc::Service::MarkMethodAsync(0); ::grpc::Service::MarkMethodAsync(0);
} }
~WithAsyncMethod_MethodA1() GRPC_OVERRIDE { ~WithAsyncMethod_MethodA1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -160,11 +160,11 @@ class ServiceA GRPC_FINAL {
WithAsyncMethod_MethodA2() { WithAsyncMethod_MethodA2() {
::grpc::Service::MarkMethodAsync(1); ::grpc::Service::MarkMethodAsync(1);
} }
~WithAsyncMethod_MethodA2() GRPC_OVERRIDE { ~WithAsyncMethod_MethodA2() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -181,11 +181,11 @@ class ServiceA GRPC_FINAL {
WithGenericMethod_MethodA1() { WithGenericMethod_MethodA1() {
::grpc::Service::MarkMethodGeneric(0); ::grpc::Service::MarkMethodGeneric(0);
} }
~WithGenericMethod_MethodA1() GRPC_OVERRIDE { ~WithGenericMethod_MethodA1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -198,11 +198,11 @@ class ServiceA GRPC_FINAL {
WithGenericMethod_MethodA2() { WithGenericMethod_MethodA2() {
::grpc::Service::MarkMethodGeneric(1); ::grpc::Service::MarkMethodGeneric(1);
} }
~WithGenericMethod_MethodA2() GRPC_OVERRIDE { ~WithGenericMethod_MethodA2() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -216,11 +216,11 @@ class ServiceA GRPC_FINAL {
::grpc::Service::MarkMethodStreamed(0, ::grpc::Service::MarkMethodStreamed(0,
new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2))); new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2)));
} }
~WithStreamedUnaryMethod_MethodA1() GRPC_OVERRIDE { ~WithStreamedUnaryMethod_MethodA1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable regular version of this method // disable regular version of this method
::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -233,7 +233,7 @@ class ServiceA GRPC_FINAL {
}; };
// ServiceB leading comment 1 // ServiceB leading comment 1
class ServiceB GRPC_FINAL { class ServiceB final {
public: public:
class StubInterface { class StubInterface {
public: public:
@ -247,17 +247,17 @@ class ServiceB GRPC_FINAL {
private: private:
virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
}; };
class Stub GRPC_FINAL : public StubInterface { class Stub final : public StubInterface {
public: public:
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
::grpc::Status MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) GRPC_OVERRIDE; ::grpc::Status MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) override;
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq)); return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq));
} }
private: private:
std::shared_ptr< ::grpc::ChannelInterface> channel_; std::shared_ptr< ::grpc::ChannelInterface> channel_;
::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) GRPC_OVERRIDE; ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
const ::grpc::RpcMethod rpcmethod_MethodB1_; const ::grpc::RpcMethod rpcmethod_MethodB1_;
}; };
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
@ -278,11 +278,11 @@ class ServiceB GRPC_FINAL {
WithAsyncMethod_MethodB1() { WithAsyncMethod_MethodB1() {
::grpc::Service::MarkMethodAsync(0); ::grpc::Service::MarkMethodAsync(0);
} }
~WithAsyncMethod_MethodB1() GRPC_OVERRIDE { ~WithAsyncMethod_MethodB1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -299,11 +299,11 @@ class ServiceB GRPC_FINAL {
WithGenericMethod_MethodB1() { WithGenericMethod_MethodB1() {
::grpc::Service::MarkMethodGeneric(0); ::grpc::Service::MarkMethodGeneric(0);
} }
~WithGenericMethod_MethodB1() GRPC_OVERRIDE { ~WithGenericMethod_MethodB1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -317,11 +317,11 @@ class ServiceB GRPC_FINAL {
::grpc::Service::MarkMethodStreamed(0, ::grpc::Service::MarkMethodStreamed(0,
new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2))); new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2)));
} }
~WithStreamedUnaryMethod_MethodB1() GRPC_OVERRIDE { ~WithStreamedUnaryMethod_MethodB1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable regular version of this method // disable regular version of this method
::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }

@ -56,7 +56,7 @@ class TestAuthPropertyIterator : public AuthPropertyIterator {
class AuthPropertyIteratorTest : public ::testing::Test { class AuthPropertyIteratorTest : public ::testing::Test {
protected: protected:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
ctx_ = grpc_auth_context_create(NULL); ctx_ = grpc_auth_context_create(NULL);
grpc_auth_context_add_cstring_property(ctx_, "name", "chapi"); grpc_auth_context_add_cstring_property(ctx_, "name", "chapi");
grpc_auth_context_add_cstring_property(ctx_, "name", "chapo"); grpc_auth_context_add_cstring_property(ctx_, "name", "chapo");
@ -64,7 +64,7 @@ class AuthPropertyIteratorTest : public ::testing::Test {
EXPECT_EQ(1, EXPECT_EQ(1,
grpc_auth_context_set_peer_identity_property_name(ctx_, "name")); grpc_auth_context_set_peer_identity_property_name(ctx_, "name"));
} }
void TearDown() GRPC_OVERRIDE { grpc_auth_context_release(ctx_); } void TearDown() override { grpc_auth_context_release(ctx_); }
grpc_auth_context* ctx_; grpc_auth_context* ctx_;
}; };

@ -211,10 +211,10 @@ bool plugin_has_sync_methods(std::unique_ptr<ServerBuilderPlugin>& plugin) {
// that needs to be tested here. // that needs to be tested here.
class ServerBuilderSyncPluginDisabler : public ::grpc::ServerBuilderOption { class ServerBuilderSyncPluginDisabler : public ::grpc::ServerBuilderOption {
public: public:
void UpdateArguments(ChannelArguments* arg) GRPC_OVERRIDE {} void UpdateArguments(ChannelArguments* arg) override {}
void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) void UpdatePlugins(
GRPC_OVERRIDE { std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
plugins->erase(std::remove_if(plugins->begin(), plugins->end(), plugins->erase(std::remove_if(plugins->begin(), plugins->end(),
plugin_has_sync_methods), plugin_has_sync_methods),
plugins->end()); plugins->end());
@ -246,7 +246,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> {
protected: protected:
AsyncEnd2endTest() { GetParam().Log(); } AsyncEnd2endTest() { GetParam().Log(); }
void SetUp() GRPC_OVERRIDE { void SetUp() override {
poll_overrider_.reset(new PollingOverrider(!GetParam().disable_blocking)); poll_overrider_.reset(new PollingOverrider(!GetParam().disable_blocking));
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
@ -269,7 +269,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> {
gpr_tls_set(&g_is_async_end2end_test, 1); gpr_tls_set(&g_is_async_end2end_test, 1);
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
server_->Shutdown(); server_->Shutdown();
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;

@ -58,11 +58,10 @@ using namespace gflags;
namespace grpc { namespace grpc {
namespace testing { namespace testing {
class ServiceImpl GRPC_FINAL class ServiceImpl final : public ::grpc::testing::EchoTestService::Service {
: public ::grpc::testing::EchoTestService::Service { Status BidiStream(
Status BidiStream(ServerContext* context, ServerContext* context,
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
GRPC_OVERRIDE {
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
while (stream->Read(&request)) { while (stream->Read(&request)) {

@ -92,12 +92,12 @@ class TestMetadataCredentialsPlugin : public MetadataCredentialsPlugin {
is_blocking_(is_blocking), is_blocking_(is_blocking),
is_successful_(is_successful) {} is_successful_(is_successful) {}
bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } bool IsBlocking() const override { return is_blocking_; }
Status GetMetadata(grpc::string_ref service_url, grpc::string_ref method_name, Status GetMetadata(
const grpc::AuthContext& channel_auth_context, grpc::string_ref service_url, grpc::string_ref method_name,
std::multimap<grpc::string, grpc::string>* metadata) const grpc::AuthContext& channel_auth_context,
GRPC_OVERRIDE { std::multimap<grpc::string, grpc::string>* metadata) override {
EXPECT_GT(service_url.length(), 0UL); EXPECT_GT(service_url.length(), 0UL);
EXPECT_GT(method_name.length(), 0UL); EXPECT_GT(method_name.length(), 0UL);
EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated()); EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated());
@ -145,11 +145,11 @@ class TestAuthMetadataProcessor : public AuthMetadataProcessor {
} }
// Interface implementation // Interface implementation
bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } bool IsBlocking() const override { return is_blocking_; }
Status Process(const InputMetadata& auth_metadata, AuthContext* context, Status Process(const InputMetadata& auth_metadata, AuthContext* context,
OutputMetadata* consumed_auth_metadata, OutputMetadata* consumed_auth_metadata,
OutputMetadata* response_metadata) GRPC_OVERRIDE { OutputMetadata* response_metadata) override {
EXPECT_TRUE(consumed_auth_metadata != nullptr); EXPECT_TRUE(consumed_auth_metadata != nullptr);
EXPECT_TRUE(context != nullptr); EXPECT_TRUE(context != nullptr);
EXPECT_TRUE(response_metadata != nullptr); EXPECT_TRUE(response_metadata != nullptr);
@ -185,7 +185,7 @@ class Proxy : public ::grpc::testing::EchoTestService::Service {
: stub_(grpc::testing::EchoTestService::NewStub(channel)) {} : stub_(grpc::testing::EchoTestService::NewStub(channel)) {}
Status Echo(ServerContext* server_context, const EchoRequest* request, Status Echo(ServerContext* server_context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
std::unique_ptr<ClientContext> client_context = std::unique_ptr<ClientContext> client_context =
ClientContext::FromServerContext(*server_context); ClientContext::FromServerContext(*server_context);
return stub_->Echo(client_context.get(), *request, response); return stub_->Echo(client_context.get(), *request, response);
@ -199,7 +199,7 @@ class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::EchoTestService::Service { : public ::grpc::testing::duplicate::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message("no package"); response->set_message("no package");
return Status::OK; return Status::OK;
} }
@ -229,7 +229,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> {
GetParam().Log(); GetParam().Log();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
if (is_server_started_) { if (is_server_started_) {
server_->Shutdown(); server_->Shutdown();
if (proxy_server_) proxy_server_->Shutdown(); if (proxy_server_) proxy_server_->Shutdown();
@ -1496,7 +1496,7 @@ class ResourceQuotaEnd2endTest : public End2endTest {
ResourceQuotaEnd2endTest() ResourceQuotaEnd2endTest()
: server_resource_quota_("server_resource_quota") {} : server_resource_quota_("server_resource_quota") {}
virtual void ConfigureServerBuilder(ServerBuilder* builder) GRPC_OVERRIDE { virtual void ConfigureServerBuilder(ServerBuilder* builder) override {
builder->SetResourceQuota(server_resource_quota_); builder->SetResourceQuota(server_resource_quota_);
} }

@ -78,35 +78,35 @@ namespace {
int global_num_connections = 0; int global_num_connections = 0;
int global_num_calls = 0; int global_num_calls = 0;
mutex global_mu; std::mutex global_mu;
void IncrementConnectionCounter() { void IncrementConnectionCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
++global_num_connections; ++global_num_connections;
} }
void ResetConnectionCounter() { void ResetConnectionCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
global_num_connections = 0; global_num_connections = 0;
} }
int GetConnectionCounterValue() { int GetConnectionCounterValue() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
return global_num_connections; return global_num_connections;
} }
void IncrementCallCounter() { void IncrementCallCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
++global_num_calls; ++global_num_calls;
} }
void ResetCallCounter() { void ResetCallCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
global_num_calls = 0; global_num_calls = 0;
} }
int GetCallCounterValue() { int GetCallCounterValue() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
return global_num_calls; return global_num_calls;
} }
@ -126,7 +126,7 @@ class CallDataImpl : public CallData {
: CallData(channel_data) {} : CallData(channel_data) {}
void StartTransportStreamOp(grpc_exec_ctx* exec_ctx, grpc_call_element* elem, void StartTransportStreamOp(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
TransportStreamOp* op) GRPC_OVERRIDE { TransportStreamOp* op) override {
// Incrementing the counter could be done from the ctor, but we want // Incrementing the counter could be done from the ctor, but we want
// to test that the individual methods are actually called correctly. // to test that the individual methods are actually called correctly.
if (op->recv_initial_metadata() != nullptr) IncrementCallCounter(); if (op->recv_initial_metadata() != nullptr) IncrementCallCounter();
@ -138,7 +138,7 @@ class FilterEnd2endTest : public ::testing::Test {
protected: protected:
FilterEnd2endTest() : server_host_("localhost") {} FilterEnd2endTest() : server_host_("localhost") {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << server_host_ << ":" << port; server_address_ << server_host_ << ":" << port;
// Setup server // Setup server
@ -150,7 +150,7 @@ class FilterEnd2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
server_->Shutdown(); server_->Shutdown();
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;

@ -75,7 +75,7 @@ class GenericEnd2endTest : public ::testing::Test {
protected: protected:
GenericEnd2endTest() : server_host_("localhost") {} GenericEnd2endTest() : server_host_("localhost") {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << server_host_ << ":" << port; server_address_ << server_host_ << ":" << port;
// Setup server // Setup server
@ -91,7 +91,7 @@ class GenericEnd2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
server_->Shutdown(); server_->Shutdown();
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;

@ -188,7 +188,7 @@ class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::EchoTestService::Service { : public ::grpc::testing::duplicate::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request->message() + "_dup"); response->set_message(request->message() + "_dup");
return Status::OK; return Status::OK;
} }
@ -230,7 +230,7 @@ class HybridEnd2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
if (server_) { if (server_) {
server_->Shutdown(); server_->Shutdown();
} }
@ -449,9 +449,9 @@ class StreamedUnaryDupPkg
: public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo< : public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo<
TestServiceImplDupPkg> { TestServiceImplDupPkg> {
public: public:
Status StreamedEcho(ServerContext* context, Status StreamedEcho(
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -487,9 +487,9 @@ TEST_F(HybridEnd2endTest,
class FullyStreamedUnaryDupPkg class FullyStreamedUnaryDupPkg
: public duplicate::EchoTestService::StreamedUnaryService { : public duplicate::EchoTestService::StreamedUnaryService {
public: public:
Status StreamedEcho(ServerContext* context, Status StreamedEcho(
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -528,7 +528,7 @@ class SplitResponseStreamDupPkg
public: public:
Status StreamedResponseStream( Status StreamedResponseStream(
ServerContext* context, ServerContext* context,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -568,7 +568,7 @@ class FullySplitStreamedDupPkg
public: public:
Status StreamedResponseStream( Status StreamedResponseStream(
ServerContext* context, ServerContext* context,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -605,9 +605,9 @@ TEST_F(HybridEnd2endTest,
// Add a second service that is fully server streamed // Add a second service that is fully server streamed
class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService { class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService {
public: public:
Status StreamedEcho(ServerContext* context, Status StreamedEcho(
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -620,7 +620,7 @@ class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService {
} }
Status StreamedResponseStream( Status StreamedResponseStream(
ServerContext* context, ServerContext* context,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;

@ -61,46 +61,44 @@ namespace testing {
namespace { namespace {
template <class W, class R> template <class W, class R>
class MockClientReaderWriter GRPC_FINAL class MockClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
: public ClientReaderWriterInterface<W, R> {
public: public:
void WaitForInitialMetadata() GRPC_OVERRIDE {} void WaitForInitialMetadata() override {}
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = UINT_MAX; *sz = UINT_MAX;
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { return true; } bool Read(R* msg) override { return true; }
bool Write(const W& msg) GRPC_OVERRIDE { return true; } bool Write(const W& msg) override { return true; }
bool WritesDone() GRPC_OVERRIDE { return true; } bool WritesDone() override { return true; }
Status Finish() GRPC_OVERRIDE { return Status::OK; } Status Finish() override { return Status::OK; }
}; };
template <> template <>
class MockClientReaderWriter<EchoRequest, EchoResponse> GRPC_FINAL class MockClientReaderWriter<EchoRequest, EchoResponse> final
: public ClientReaderWriterInterface<EchoRequest, EchoResponse> { : public ClientReaderWriterInterface<EchoRequest, EchoResponse> {
public: public:
MockClientReaderWriter() : writes_done_(false) {} MockClientReaderWriter() : writes_done_(false) {}
void WaitForInitialMetadata() GRPC_OVERRIDE {} void WaitForInitialMetadata() override {}
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = UINT_MAX; *sz = UINT_MAX;
return true; return true;
} }
bool Read(EchoResponse* msg) GRPC_OVERRIDE { bool Read(EchoResponse* msg) override {
if (writes_done_) return false; if (writes_done_) return false;
msg->set_message(last_message_); msg->set_message(last_message_);
return true; return true;
} }
bool Write(const EchoRequest& msg, bool Write(const EchoRequest& msg, const WriteOptions& options) override {
const WriteOptions& options) GRPC_OVERRIDE {
gpr_log(GPR_INFO, "mock recv msg %s", msg.message().c_str()); gpr_log(GPR_INFO, "mock recv msg %s", msg.message().c_str());
last_message_ = msg.message(); last_message_ = msg.message();
return true; return true;
} }
bool WritesDone() GRPC_OVERRIDE { bool WritesDone() override {
writes_done_ = true; writes_done_ = true;
return true; return true;
} }
Status Finish() GRPC_OVERRIDE { return Status::OK; } Status Finish() override { return Status::OK; }
private: private:
bool writes_done_; bool writes_done_;
@ -113,51 +111,51 @@ class MockStub : public EchoTestService::StubInterface {
MockStub() {} MockStub() {}
~MockStub() {} ~MockStub() {}
Status Echo(ClientContext* context, const EchoRequest& request, Status Echo(ClientContext* context, const EchoRequest& request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request.message()); response->set_message(request.message());
return Status::OK; return Status::OK;
} }
Status Unimplemented(ClientContext* context, const EchoRequest& request, Status Unimplemented(ClientContext* context, const EchoRequest& request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
return Status::OK; return Status::OK;
} }
private: private:
ClientAsyncResponseReaderInterface<EchoResponse>* AsyncEchoRaw( ClientAsyncResponseReaderInterface<EchoResponse>* AsyncEchoRaw(
ClientContext* context, const EchoRequest& request, ClientContext* context, const EchoRequest& request,
CompletionQueue* cq) GRPC_OVERRIDE { CompletionQueue* cq) override {
return nullptr; return nullptr;
} }
ClientWriterInterface<EchoRequest>* RequestStreamRaw( ClientWriterInterface<EchoRequest>* RequestStreamRaw(
ClientContext* context, EchoResponse* response) GRPC_OVERRIDE { ClientContext* context, EchoResponse* response) override {
return nullptr; return nullptr;
} }
ClientAsyncWriterInterface<EchoRequest>* AsyncRequestStreamRaw( ClientAsyncWriterInterface<EchoRequest>* AsyncRequestStreamRaw(
ClientContext* context, EchoResponse* response, CompletionQueue* cq, ClientContext* context, EchoResponse* response, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE { void* tag) override {
return nullptr; return nullptr;
} }
ClientReaderInterface<EchoResponse>* ResponseStreamRaw( ClientReaderInterface<EchoResponse>* ResponseStreamRaw(
ClientContext* context, const EchoRequest& request) GRPC_OVERRIDE { ClientContext* context, const EchoRequest& request) override {
return nullptr; return nullptr;
} }
ClientAsyncReaderInterface<EchoResponse>* AsyncResponseStreamRaw( ClientAsyncReaderInterface<EchoResponse>* AsyncResponseStreamRaw(
ClientContext* context, const EchoRequest& request, CompletionQueue* cq, ClientContext* context, const EchoRequest& request, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE { void* tag) override {
return nullptr; return nullptr;
} }
ClientReaderWriterInterface<EchoRequest, EchoResponse>* BidiStreamRaw( ClientReaderWriterInterface<EchoRequest, EchoResponse>* BidiStreamRaw(
ClientContext* context) GRPC_OVERRIDE { ClientContext* context) override {
return new MockClientReaderWriter<EchoRequest, EchoResponse>(); return new MockClientReaderWriter<EchoRequest, EchoResponse>();
} }
ClientAsyncReaderWriterInterface<EchoRequest, EchoResponse>* ClientAsyncReaderWriterInterface<EchoRequest, EchoResponse>*
AsyncBidiStreamRaw(ClientContext* context, CompletionQueue* cq, AsyncBidiStreamRaw(ClientContext* context, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE { void* tag) override {
return nullptr; return nullptr;
} }
ClientAsyncResponseReaderInterface<EchoResponse>* AsyncUnimplementedRaw( ClientAsyncResponseReaderInterface<EchoResponse>* AsyncUnimplementedRaw(
ClientContext* context, const EchoRequest& request, ClientContext* context, const EchoRequest& request,
CompletionQueue* cq) GRPC_OVERRIDE { CompletionQueue* cq) override {
return nullptr; return nullptr;
} }
}; };
@ -216,14 +214,14 @@ class FakeClient {
class TestServiceImpl : public EchoTestService::Service { class TestServiceImpl : public EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request->message()); response->set_message(request->message());
return Status::OK; return Status::OK;
} }
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
while (stream->Read(&request)) { while (stream->Read(&request)) {
@ -239,7 +237,7 @@ class MockTest : public ::testing::Test {
protected: protected:
MockTest() {} MockTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port; server_address_ << "localhost:" << port;
// Setup server // Setup server
@ -250,7 +248,7 @@ class MockTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void TearDown() override { server_->Shutdown(); }
void ResetStub() { void ResetStub() {
std::shared_ptr<Channel> channel = std::shared_ptr<Channel> channel =

@ -56,7 +56,7 @@ class ProtoServerReflectionTest : public ::testing::Test {
public: public:
ProtoServerReflectionTest() {} ProtoServerReflectionTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
ref_desc_pool_ = protobuf::DescriptorPool::generated_pool(); ref_desc_pool_ = protobuf::DescriptorPool::generated_pool();

@ -66,21 +66,21 @@ class MyTestServiceImpl : public TestServiceImpl {
MyTestServiceImpl() : request_count_(0) {} MyTestServiceImpl() : request_count_(0) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
{ {
unique_lock<mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
++request_count_; ++request_count_;
} }
return TestServiceImpl::Echo(context, request, response); return TestServiceImpl::Echo(context, request, response);
} }
int request_count() { int request_count() {
unique_lock<mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
return request_count_; return request_count_;
} }
private: private:
mutex mu_; std::mutex mu_;
int request_count_; int request_count_;
}; };
@ -94,7 +94,7 @@ class RoundRobinEnd2endTest : public ::testing::Test {
} }
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
for (size_t i = 0; i < servers_.size(); ++i) { for (size_t i = 0; i < servers_.size(); ++i) {
servers_[i]->Shutdown(); servers_[i]->Shutdown();
} }
@ -139,7 +139,7 @@ class RoundRobinEnd2endTest : public ::testing::Test {
std::condition_variable cond; std::condition_variable cond;
thread_.reset(new std::thread( thread_.reset(new std::thread(
std::bind(&ServerData::Start, this, server_host, &mu, &cond))); std::bind(&ServerData::Start, this, server_host, &mu, &cond)));
unique_lock<mutex> lock(mu); std::unique_lock<std::mutex> lock(mu);
cond.wait(lock); cond.wait(lock);
gpr_log(GPR_INFO, "server startup complete"); gpr_log(GPR_INFO, "server startup complete");
} }
@ -153,7 +153,7 @@ class RoundRobinEnd2endTest : public ::testing::Test {
InsecureServerCredentials()); InsecureServerCredentials());
builder.RegisterService(&service_); builder.RegisterService(&service_);
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
lock_guard<mutex> lock(*mu); std::lock_guard<std::mutex> lock(*mu);
cond->notify_one(); cond->notify_one();
} }

@ -31,13 +31,14 @@
* *
*/ */
#include <thread>
#include <grpc++/channel.h> #include <grpc++/channel.h>
#include <grpc++/client_context.h> #include <grpc++/client_context.h>
#include <grpc++/create_channel.h> #include <grpc++/create_channel.h>
#include <grpc++/impl/server_builder_option.h> #include <grpc++/impl/server_builder_option.h>
#include <grpc++/impl/server_builder_plugin.h> #include <grpc++/impl/server_builder_plugin.h>
#include <grpc++/impl/server_initializer.h> #include <grpc++/impl/server_initializer.h>
#include <grpc++/impl/thd.h>
#include <grpc++/security/credentials.h> #include <grpc++/security/credentials.h>
#include <grpc++/security/server_credentials.h> #include <grpc++/security/server_credentials.h>
#include <grpc++/server.h> #include <grpc++/server.h>
@ -65,29 +66,29 @@ class TestServerBuilderPlugin : public ServerBuilderPlugin {
register_service_ = false; register_service_ = false;
} }
grpc::string name() GRPC_OVERRIDE { return PLUGIN_NAME; } grpc::string name() override { return PLUGIN_NAME; }
void InitServer(ServerInitializer* si) GRPC_OVERRIDE { void InitServer(ServerInitializer* si) override {
init_server_is_called_ = true; init_server_is_called_ = true;
if (register_service_) { if (register_service_) {
si->RegisterService(service_); si->RegisterService(service_);
} }
} }
void Finish(ServerInitializer* si) GRPC_OVERRIDE { finish_is_called_ = true; } void Finish(ServerInitializer* si) override { finish_is_called_ = true; }
void ChangeArguments(const grpc::string& name, void* value) GRPC_OVERRIDE { void ChangeArguments(const grpc::string& name, void* value) override {
change_arguments_is_called_ = true; change_arguments_is_called_ = true;
} }
bool has_async_methods() const GRPC_OVERRIDE { bool has_async_methods() const override {
if (register_service_) { if (register_service_) {
return service_->has_async_methods(); return service_->has_async_methods();
} }
return false; return false;
} }
bool has_sync_methods() const GRPC_OVERRIDE { bool has_sync_methods() const override {
if (register_service_) { if (register_service_) {
return service_->has_synchronous_methods(); return service_->has_synchronous_methods();
} }
@ -112,10 +113,10 @@ class InsertPluginServerBuilderOption : public ServerBuilderOption {
public: public:
InsertPluginServerBuilderOption() { register_service_ = false; } InsertPluginServerBuilderOption() { register_service_ = false; }
void UpdateArguments(ChannelArguments* arg) GRPC_OVERRIDE {} void UpdateArguments(ChannelArguments* arg) override {}
void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) void UpdatePlugins(
GRPC_OVERRIDE { std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
plugins->clear(); plugins->clear();
std::unique_ptr<TestServerBuilderPlugin> plugin( std::unique_ptr<TestServerBuilderPlugin> plugin(
@ -154,7 +155,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
public: public:
ServerBuilderPluginTest() {} ServerBuilderPluginTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
builder_.reset(new ServerBuilder()); builder_.reset(new ServerBuilder());
} }
@ -191,7 +192,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
// we run some tests without a service, and for those we need to supply a // we run some tests without a service, and for those we need to supply a
// frequently polled completion queue // frequently polled completion queue
cq_ = builder_->AddCompletionQueue(); cq_ = builder_->AddCompletionQueue();
cq_thread_ = new grpc::thread(&ServerBuilderPluginTest::RunCQ, this); cq_thread_ = new std::thread(&ServerBuilderPluginTest::RunCQ, this);
server_ = builder_->BuildAndStart(); server_ = builder_->BuildAndStart();
EXPECT_TRUE(CheckPresent()); EXPECT_TRUE(CheckPresent());
} }
@ -202,7 +203,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
stub_ = grpc::testing::EchoTestService::NewStub(channel_); stub_ = grpc::testing::EchoTestService::NewStub(channel_);
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
auto plugin = CheckPresent(); auto plugin = CheckPresent();
EXPECT_TRUE(plugin); EXPECT_TRUE(plugin);
EXPECT_TRUE(plugin->init_server_is_called()); EXPECT_TRUE(plugin->init_server_is_called());
@ -225,7 +226,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<ServerCompletionQueue> cq_; std::unique_ptr<ServerCompletionQueue> cq_;
std::unique_ptr<Server> server_; std::unique_ptr<Server> server_;
grpc::thread* cq_thread_; std::thread* cq_thread_;
TestServiceImpl service_; TestServiceImpl service_;
int port_; int port_;

@ -60,14 +60,13 @@ namespace testing {
namespace { namespace {
class ServiceImpl GRPC_FINAL class ServiceImpl final : public ::grpc::testing::EchoTestService::Service {
: public ::grpc::testing::EchoTestService::Service {
public: public:
ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {} ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {}
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
bidi_stream_count_++; bidi_stream_count_++;
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
@ -82,7 +81,7 @@ class ServiceImpl GRPC_FINAL
} }
Status ResponseStream(ServerContext* context, const EchoRequest* request, Status ResponseStream(ServerContext* context, const EchoRequest* request,
ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { ServerWriter<EchoResponse>* writer) override {
EchoResponse response; EchoResponse response;
response_stream_count_++; response_stream_count_++;
for (int i = 0;; i++) { for (int i = 0;; i++) {

@ -61,7 +61,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {} explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
gpr_event_set(ev_, (void*)1); gpr_event_set(ev_, (void*)1);
while (!context->IsCancelled()) { while (!context->IsCancelled()) {
} }
@ -76,7 +76,7 @@ class ShutdownTest : public ::testing::Test {
public: public:
ShutdownTest() : shutdown_(false), service_(&ev_) { gpr_event_init(&ev_); } ShutdownTest() : shutdown_(false), service_(&ev_) { gpr_event_init(&ev_); }
void SetUp() GRPC_OVERRIDE { void SetUp() override {
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
server_ = SetUpServer(port_); server_ = SetUpServer(port_);
} }
@ -91,7 +91,7 @@ class ShutdownTest : public ::testing::Test {
return server; return server;
} }
void TearDown() GRPC_OVERRIDE { GPR_ASSERT(shutdown_); } void TearDown() override { GPR_ASSERT(shutdown_); }
void ResetStub() { void ResetStub() {
string target = "dns:localhost:" + to_string(port_); string target = "dns:localhost:" + to_string(port_);

@ -121,9 +121,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
} }
// Only implement the one method we will be calling for brevity. // Only implement the one method we will be calling for brevity.
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
EchoRequest request; EchoRequest request;
gpr_atm should_exit; gpr_atm should_exit;
gpr_atm_rel_store(&should_exit, static_cast<gpr_atm>(0)); gpr_atm_rel_store(&should_exit, static_cast<gpr_atm>(0));
@ -147,7 +147,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
class End2endTest : public ::testing::Test { class End2endTest : public ::testing::Test {
protected: protected:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port; server_address_ << "localhost:" << port;
// Setup server // Setup server
@ -158,7 +158,7 @@ class End2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void TearDown() override { server_->Shutdown(); }
void ResetStub() { void ResetStub() {
std::shared_ptr<Channel> channel = std::shared_ptr<Channel> channel =

@ -63,20 +63,20 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
: signal_client_(false), host_(new grpc::string(host)) {} : signal_client_(false), host_(new grpc::string(host)) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE; EchoResponse* response) override;
// Unimplemented is left unimplemented to test the returned error. // Unimplemented is left unimplemented to test the returned error.
Status RequestStream(ServerContext* context, Status RequestStream(ServerContext* context,
ServerReader<EchoRequest>* reader, ServerReader<EchoRequest>* reader,
EchoResponse* response) GRPC_OVERRIDE; EchoResponse* response) override;
Status ResponseStream(ServerContext* context, const EchoRequest* request, Status ResponseStream(ServerContext* context, const EchoRequest* request,
ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE; ServerWriter<EchoResponse>* writer) override;
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE; ServerReaderWriter<EchoResponse, EchoRequest>* stream) override;
bool signal_client() { bool signal_client() {
std::unique_lock<std::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);

@ -86,12 +86,12 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
TestServiceImpl() : signal_client_(false) {} TestServiceImpl() : signal_client_(false) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request->message()); response->set_message(request->message());
MaybeEchoDeadline(context, request, response); MaybeEchoDeadline(context, request, response);
if (request->has_param() && request->param().client_cancel_after_us()) { if (request->has_param() && request->param().client_cancel_after_us()) {
{ {
unique_lock<mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
signal_client_ = true; signal_client_ = true;
} }
while (!context->IsCancelled()) { while (!context->IsCancelled()) {
@ -118,7 +118,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
Status RequestStream(ServerContext* context, Status RequestStream(ServerContext* context,
ServerReader<EchoRequest>* reader, ServerReader<EchoRequest>* reader,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
EchoRequest request; EchoRequest request;
response->set_message(""); response->set_message("");
while (reader->Read(&request)) { while (reader->Read(&request)) {
@ -130,7 +130,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
// Return 3 messages. // Return 3 messages.
// TODO(yangg) make it generic by adding a parameter into EchoRequest // TODO(yangg) make it generic by adding a parameter into EchoRequest
Status ResponseStream(ServerContext* context, const EchoRequest* request, Status ResponseStream(ServerContext* context, const EchoRequest* request,
ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { ServerWriter<EchoResponse>* writer) override {
EchoResponse response; EchoResponse response;
response.set_message(request->message() + "0"); response.set_message(request->message() + "0");
writer->Write(response); writer->Write(response);
@ -142,9 +142,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
return Status::OK; return Status::OK;
} }
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
while (stream->Read(&request)) { while (stream->Read(&request)) {
@ -156,20 +156,20 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
} }
bool signal_client() { bool signal_client() {
unique_lock<mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
return signal_client_; return signal_client_;
} }
private: private:
bool signal_client_; bool signal_client_;
mutex mu_; std::mutex mu_;
}; };
class TestServiceImplDupPkg class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::EchoTestService::Service { : public ::grpc::testing::duplicate::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message("no package"); response->set_message("no package");
return Status::OK; return Status::OK;
} }
@ -215,12 +215,12 @@ class CommonStressTest {
class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> { class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> {
public: public:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
ServerBuilder builder; ServerBuilder builder;
SetUpStart(&builder, &service_); SetUpStart(&builder, &service_);
SetUpEnd(&builder); SetUpEnd(&builder);
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
TearDownStart(); TearDownStart();
TearDownEnd(); TearDownEnd();
} }
@ -232,7 +232,7 @@ class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> {
class CommonStressTestAsyncServer class CommonStressTestAsyncServer
: public CommonStressTest<grpc::testing::EchoTestService::AsyncService> { : public CommonStressTest<grpc::testing::EchoTestService::AsyncService> {
public: public:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
shutting_down_ = false; shutting_down_ = false;
ServerBuilder builder; ServerBuilder builder;
SetUpStart(&builder, &service_); SetUpStart(&builder, &service_);
@ -247,9 +247,9 @@ class CommonStressTestAsyncServer
new std::thread(&CommonStressTestAsyncServer::ProcessRpcs, this)); new std::thread(&CommonStressTestAsyncServer::ProcessRpcs, this));
} }
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
{ {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
TearDownStart(); TearDownStart();
shutting_down_ = true; shutting_down_ = true;
cq_->Shutdown(); cq_->Shutdown();
@ -292,7 +292,7 @@ class CommonStressTestAsyncServer
} }
} }
void RefreshContext(int i) { void RefreshContext(int i) {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
if (!shutting_down_) { if (!shutting_down_) {
contexts_[i].state = Context::READY; contexts_[i].state = Context::READY;
contexts_[i].srv_ctx.reset(new ServerContext); contexts_[i].srv_ctx.reset(new ServerContext);
@ -315,7 +315,7 @@ class CommonStressTestAsyncServer
::grpc::testing::EchoTestService::AsyncService service_; ::grpc::testing::EchoTestService::AsyncService service_;
std::unique_ptr<ServerCompletionQueue> cq_; std::unique_ptr<ServerCompletionQueue> cq_;
bool shutting_down_; bool shutting_down_;
mutex mu_; std::mutex mu_;
std::vector<std::thread*> server_threads_; std::vector<std::thread*> server_threads_;
}; };
@ -323,8 +323,8 @@ template <class Common>
class End2endTest : public ::testing::Test { class End2endTest : public ::testing::Test {
protected: protected:
End2endTest() {} End2endTest() {}
void SetUp() GRPC_OVERRIDE { common_.SetUp(); } void SetUp() override { common_.SetUp(); }
void TearDown() GRPC_OVERRIDE { common_.TearDown(); } void TearDown() override { common_.TearDown(); }
void ResetStub() { common_.ResetStub(); } void ResetStub() { common_.ResetStub(); }
Common common_; Common common_;
@ -369,8 +369,8 @@ class AsyncClientEnd2endTest : public ::testing::Test {
protected: protected:
AsyncClientEnd2endTest() : rpcs_outstanding_(0) {} AsyncClientEnd2endTest() : rpcs_outstanding_(0) {}
void SetUp() GRPC_OVERRIDE { common_.SetUp(); } void SetUp() override { common_.SetUp(); }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;
while (cq_.Next(&ignored_tag, &ignored_ok)) while (cq_.Next(&ignored_tag, &ignored_ok))
@ -379,7 +379,7 @@ class AsyncClientEnd2endTest : public ::testing::Test {
} }
void Wait() { void Wait() {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
while (rpcs_outstanding_ != 0) { while (rpcs_outstanding_ != 0) {
cv_.wait(l); cv_.wait(l);
} }
@ -404,7 +404,7 @@ class AsyncClientEnd2endTest : public ::testing::Test {
call->response_reader->Finish(&call->response, &call->status, call->response_reader->Finish(&call->response, &call->status,
(void*)call); (void*)call);
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
rpcs_outstanding_++; rpcs_outstanding_++;
} }
} }
@ -422,7 +422,7 @@ class AsyncClientEnd2endTest : public ::testing::Test {
bool notify; bool notify;
{ {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
rpcs_outstanding_--; rpcs_outstanding_--;
notify = (rpcs_outstanding_ == 0); notify = (rpcs_outstanding_ == 0);
} }
@ -434,8 +434,8 @@ class AsyncClientEnd2endTest : public ::testing::Test {
Common common_; Common common_;
CompletionQueue cq_; CompletionQueue cq_;
mutex mu_; std::mutex mu_;
condition_variable cv_; std::condition_variable cv_;
int rpcs_outstanding_; int rpcs_outstanding_;
}; };

@ -40,7 +40,6 @@
#include <gflags/gflags.h> #include <gflags/gflags.h>
#include <grpc++/create_channel.h> #include <grpc++/create_channel.h>
#include <grpc++/grpc++.h> #include <grpc++/grpc++.h>
#include <grpc++/impl/thd.h>
#include <grpc/support/log.h> #include <grpc/support/log.h>
#include <grpc/support/time.h> #include <grpc/support/time.h>
@ -321,7 +320,7 @@ int main(int argc, char** argv) {
gpr_log(GPR_INFO, "Starting test(s).."); gpr_log(GPR_INFO, "Starting test(s)..");
std::vector<grpc::thread> test_threads; std::vector<std::thread> test_threads;
// Create and start the test threads. // Create and start the test threads.
// Note that: // Note that:
@ -361,7 +360,7 @@ int main(int argc, char** argv) {
"/stress_test/server_%d/channel_%d/stub_%d/qps", "/stress_test/server_%d/channel_%d/stub_%d/qps",
server_idx, channel_idx, stub_idx); server_idx, channel_idx, stub_idx);
test_threads.emplace_back(grpc::thread( test_threads.emplace_back(std::thread(
&StressTestInteropClient::MainLoop, client, &StressTestInteropClient::MainLoop, client,
metrics_service.CreateQpsGauge(buffer, &is_already_created))); metrics_service.CreateQpsGauge(buffer, &is_already_created)));

@ -113,7 +113,7 @@ class ClientRequestCreator<ByteBuffer> {
} }
}; };
class HistogramEntry GRPC_FINAL { class HistogramEntry final {
public: public:
HistogramEntry() : value_used_(false), status_used_(false) {} HistogramEntry() : value_used_(false), status_used_(false) {}
bool value_used() const { return value_used_; } bool value_used() const { return value_used_; }

@ -93,8 +93,8 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
callback_(on_done), callback_(on_done),
next_issue_(next_issue), next_issue_(next_issue),
start_req_(start_req) {} start_req_(start_req) {}
~ClientRpcContextUnaryImpl() GRPC_OVERRIDE {} ~ClientRpcContextUnaryImpl() override {}
void Start(CompletionQueue* cq) GRPC_OVERRIDE { void Start(CompletionQueue* cq) override {
cq_ = cq; cq_ = cq;
if (!next_issue_) { // ready to issue if (!next_issue_) { // ready to issue
RunNextState(true, nullptr); RunNextState(true, nullptr);
@ -102,7 +102,7 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
alarm_.reset(new Alarm(cq_, next_issue_(), ClientRpcContext::tag(this))); alarm_.reset(new Alarm(cq_, next_issue_(), ClientRpcContext::tag(this)));
} }
} }
bool RunNextState(bool ok, HistogramEntry* entry) GRPC_OVERRIDE { bool RunNextState(bool ok, HistogramEntry* entry) override {
switch (next_state_) { switch (next_state_) {
case State::READY: case State::READY:
start_ = UsageTimer::Now(); start_ = UsageTimer::Now();
@ -121,7 +121,7 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
return false; return false;
} }
} }
ClientRpcContext* StartNewClone() GRPC_OVERRIDE { ClientRpcContext* StartNewClone() override {
return new ClientRpcContextUnaryImpl(stub_, req_, next_issue_, start_req_, return new ClientRpcContextUnaryImpl(stub_, req_, next_issue_, start_req_,
callback_); callback_);
} }
@ -217,7 +217,7 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
} }
return num_threads; return num_threads;
} }
void DestroyMultithreading() GRPC_OVERRIDE GRPC_FINAL { void DestroyMultithreading() override final {
for (auto ss = shutdown_state_.begin(); ss != shutdown_state_.end(); ++ss) { for (auto ss = shutdown_state_.begin(); ss != shutdown_state_.end(); ++ss) {
std::lock_guard<std::mutex> lock((*ss)->mutex); std::lock_guard<std::mutex> lock((*ss)->mutex);
(*ss)->shutdown = true; (*ss)->shutdown = true;
@ -228,8 +228,7 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
this->EndThreads(); // this needed for resolution this->EndThreads(); // this needed for resolution
} }
bool ThreadFunc(HistogramEntry* entry, bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override final {
size_t thread_idx) GRPC_OVERRIDE GRPC_FINAL {
void* got_tag; void* got_tag;
bool ok; bool ok;
@ -279,7 +278,7 @@ static std::unique_ptr<BenchmarkService::Stub> BenchmarkStubCreator(
return BenchmarkService::NewStub(ch); return BenchmarkService::NewStub(ch);
} }
class AsyncUnaryClient GRPC_FINAL class AsyncUnaryClient final
: public AsyncClient<BenchmarkService::Stub, SimpleRequest> { : public AsyncClient<BenchmarkService::Stub, SimpleRequest> {
public: public:
explicit AsyncUnaryClient(const ClientConfig& config) explicit AsyncUnaryClient(const ClientConfig& config)
@ -287,7 +286,7 @@ class AsyncUnaryClient GRPC_FINAL
config, SetupCtx, BenchmarkStubCreator) { config, SetupCtx, BenchmarkStubCreator) {
StartThreads(num_async_threads_); StartThreads(num_async_threads_);
} }
~AsyncUnaryClient() GRPC_OVERRIDE {} ~AsyncUnaryClient() override {}
private: private:
static void CheckDone(grpc::Status s, SimpleResponse* response, static void CheckDone(grpc::Status s, SimpleResponse* response,
@ -329,13 +328,13 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
callback_(on_done), callback_(on_done),
next_issue_(next_issue), next_issue_(next_issue),
start_req_(start_req) {} start_req_(start_req) {}
~ClientRpcContextStreamingImpl() GRPC_OVERRIDE {} ~ClientRpcContextStreamingImpl() override {}
void Start(CompletionQueue* cq) GRPC_OVERRIDE { void Start(CompletionQueue* cq) override {
cq_ = cq; cq_ = cq;
stream_ = start_req_(stub_, &context_, cq, ClientRpcContext::tag(this)); stream_ = start_req_(stub_, &context_, cq, ClientRpcContext::tag(this));
next_state_ = State::STREAM_IDLE; next_state_ = State::STREAM_IDLE;
} }
bool RunNextState(bool ok, HistogramEntry* entry) GRPC_OVERRIDE { bool RunNextState(bool ok, HistogramEntry* entry) override {
while (true) { while (true) {
switch (next_state_) { switch (next_state_) {
case State::STREAM_IDLE: case State::STREAM_IDLE:
@ -377,7 +376,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
} }
} }
} }
ClientRpcContext* StartNewClone() GRPC_OVERRIDE { ClientRpcContext* StartNewClone() override {
return new ClientRpcContextStreamingImpl(stub_, req_, next_issue_, return new ClientRpcContextStreamingImpl(stub_, req_, next_issue_,
start_req_, callback_); start_req_, callback_);
} }
@ -410,7 +409,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
stream_; stream_;
}; };
class AsyncStreamingClient GRPC_FINAL class AsyncStreamingClient final
: public AsyncClient<BenchmarkService::Stub, SimpleRequest> { : public AsyncClient<BenchmarkService::Stub, SimpleRequest> {
public: public:
explicit AsyncStreamingClient(const ClientConfig& config) explicit AsyncStreamingClient(const ClientConfig& config)
@ -419,7 +418,7 @@ class AsyncStreamingClient GRPC_FINAL
StartThreads(num_async_threads_); StartThreads(num_async_threads_);
} }
~AsyncStreamingClient() GRPC_OVERRIDE {} ~AsyncStreamingClient() override {}
private: private:
static void CheckDone(grpc::Status s, SimpleResponse* response) {} static void CheckDone(grpc::Status s, SimpleResponse* response) {}
@ -458,8 +457,8 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
callback_(on_done), callback_(on_done),
next_issue_(next_issue), next_issue_(next_issue),
start_req_(start_req) {} start_req_(start_req) {}
~ClientRpcContextGenericStreamingImpl() GRPC_OVERRIDE {} ~ClientRpcContextGenericStreamingImpl() override {}
void Start(CompletionQueue* cq) GRPC_OVERRIDE { void Start(CompletionQueue* cq) override {
cq_ = cq; cq_ = cq;
const grpc::string kMethodName( const grpc::string kMethodName(
"/grpc.testing.BenchmarkService/StreamingCall"); "/grpc.testing.BenchmarkService/StreamingCall");
@ -467,7 +466,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
ClientRpcContext::tag(this)); ClientRpcContext::tag(this));
next_state_ = State::STREAM_IDLE; next_state_ = State::STREAM_IDLE;
} }
bool RunNextState(bool ok, HistogramEntry* entry) GRPC_OVERRIDE { bool RunNextState(bool ok, HistogramEntry* entry) override {
while (true) { while (true) {
switch (next_state_) { switch (next_state_) {
case State::STREAM_IDLE: case State::STREAM_IDLE:
@ -509,7 +508,7 @@ class ClientRpcContextGenericStreamingImpl : public ClientRpcContext {
} }
} }
} }
ClientRpcContext* StartNewClone() GRPC_OVERRIDE { ClientRpcContext* StartNewClone() override {
return new ClientRpcContextGenericStreamingImpl(stub_, req_, next_issue_, return new ClientRpcContextGenericStreamingImpl(stub_, req_, next_issue_,
start_req_, callback_); start_req_, callback_);
} }
@ -546,7 +545,7 @@ static std::unique_ptr<grpc::GenericStub> GenericStubCreator(
return std::unique_ptr<grpc::GenericStub>(new grpc::GenericStub(ch)); return std::unique_ptr<grpc::GenericStub>(new grpc::GenericStub(ch));
} }
class GenericAsyncStreamingClient GRPC_FINAL class GenericAsyncStreamingClient final
: public AsyncClient<grpc::GenericStub, ByteBuffer> { : public AsyncClient<grpc::GenericStub, ByteBuffer> {
public: public:
explicit GenericAsyncStreamingClient(const ClientConfig& config) explicit GenericAsyncStreamingClient(const ClientConfig& config)
@ -555,7 +554,7 @@ class GenericAsyncStreamingClient GRPC_FINAL
StartThreads(num_async_threads_); StartThreads(num_async_threads_);
} }
~GenericAsyncStreamingClient() GRPC_OVERRIDE {} ~GenericAsyncStreamingClient() override {}
private: private:
static void CheckDone(grpc::Status s, ByteBuffer* response) {} static void CheckDone(grpc::Status s, ByteBuffer* response) {}

@ -108,10 +108,10 @@ class SynchronousClient
std::vector<SimpleResponse> responses_; std::vector<SimpleResponse> responses_;
private: private:
void DestroyMultithreading() GRPC_OVERRIDE GRPC_FINAL { EndThreads(); } void DestroyMultithreading() override final { EndThreads(); }
}; };
class SynchronousUnaryClient GRPC_FINAL : public SynchronousClient { class SynchronousUnaryClient final : public SynchronousClient {
public: public:
SynchronousUnaryClient(const ClientConfig& config) SynchronousUnaryClient(const ClientConfig& config)
: SynchronousClient(config) { : SynchronousClient(config) {
@ -119,7 +119,7 @@ class SynchronousUnaryClient GRPC_FINAL : public SynchronousClient {
} }
~SynchronousUnaryClient() {} ~SynchronousUnaryClient() {}
bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) GRPC_OVERRIDE { bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
if (!WaitToIssue(thread_idx)) { if (!WaitToIssue(thread_idx)) {
return true; return true;
} }
@ -135,7 +135,7 @@ class SynchronousUnaryClient GRPC_FINAL : public SynchronousClient {
} }
}; };
class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient { class SynchronousStreamingClient final : public SynchronousClient {
public: public:
SynchronousStreamingClient(const ClientConfig& config) SynchronousStreamingClient(const ClientConfig& config)
: SynchronousClient(config) { : SynchronousClient(config) {
@ -165,7 +165,7 @@ class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
delete[] context_; delete[] context_;
} }
bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) GRPC_OVERRIDE { bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override {
if (!WaitToIssue(thread_idx)) { if (!WaitToIssue(thread_idx)) {
return true; return true;
} }

@ -69,11 +69,11 @@ inline RandomDistInterface::~RandomDistInterface() {}
// independent identical stationary sources. For more information, // independent identical stationary sources. For more information,
// see http://en.wikipedia.org/wiki/Exponential_distribution // see http://en.wikipedia.org/wiki/Exponential_distribution
class ExpDist GRPC_FINAL : public RandomDistInterface { class ExpDist final : public RandomDistInterface {
public: public:
explicit ExpDist(double lambda) : lambda_recip_(1.0 / lambda) {} explicit ExpDist(double lambda) : lambda_recip_(1.0 / lambda) {}
~ExpDist() GRPC_OVERRIDE {} ~ExpDist() override {}
double transform(double uni) const GRPC_OVERRIDE { double transform(double uni) const override {
// Note: Use 1.0-uni above to avoid NaN if uni is 0 // Note: Use 1.0-uni above to avoid NaN if uni is 0
return lambda_recip_ * (-log(1.0 - uni)); return lambda_recip_ * (-log(1.0 - uni));
} }

@ -100,7 +100,7 @@ static std::unique_ptr<Server> CreateServer(const ServerConfig& config) {
abort(); abort();
} }
class ScopedProfile GRPC_FINAL { class ScopedProfile final {
public: public:
ScopedProfile(const char* filename, bool enable) : enable_(enable) { ScopedProfile(const char* filename, bool enable) : enable_(enable) {
if (enable_) grpc_profiler_start(filename); if (enable_) grpc_profiler_start(filename);
@ -113,14 +113,14 @@ class ScopedProfile GRPC_FINAL {
const bool enable_; const bool enable_;
}; };
class WorkerServiceImpl GRPC_FINAL : public WorkerService::Service { class WorkerServiceImpl final : public WorkerService::Service {
public: public:
WorkerServiceImpl(int server_port, QpsWorker* worker) WorkerServiceImpl(int server_port, QpsWorker* worker)
: acquired_(false), server_port_(server_port), worker_(worker) {} : acquired_(false), server_port_(server_port), worker_(worker) {}
Status RunClient(ServerContext* ctx, Status RunClient(
ServerReaderWriter<ClientStatus, ClientArgs>* stream) ServerContext* ctx,
GRPC_OVERRIDE { ServerReaderWriter<ClientStatus, ClientArgs>* stream) override {
InstanceGuard g(this); InstanceGuard g(this);
if (!g.Acquired()) { if (!g.Acquired()) {
return Status(StatusCode::RESOURCE_EXHAUSTED, "Client worker busy"); return Status(StatusCode::RESOURCE_EXHAUSTED, "Client worker busy");
@ -132,9 +132,9 @@ class WorkerServiceImpl GRPC_FINAL : public WorkerService::Service {
return ret; return ret;
} }
Status RunServer(ServerContext* ctx, Status RunServer(
ServerReaderWriter<ServerStatus, ServerArgs>* stream) ServerContext* ctx,
GRPC_OVERRIDE { ServerReaderWriter<ServerStatus, ServerArgs>* stream) override {
InstanceGuard g(this); InstanceGuard g(this);
if (!g.Acquired()) { if (!g.Acquired()) {
return Status(StatusCode::RESOURCE_EXHAUSTED, "Server worker busy"); return Status(StatusCode::RESOURCE_EXHAUSTED, "Server worker busy");
@ -147,12 +147,12 @@ class WorkerServiceImpl GRPC_FINAL : public WorkerService::Service {
} }
Status CoreCount(ServerContext* ctx, const CoreRequest*, Status CoreCount(ServerContext* ctx, const CoreRequest*,
CoreResponse* resp) GRPC_OVERRIDE { CoreResponse* resp) override {
resp->set_cores(gpr_cpu_num_cores()); resp->set_cores(gpr_cpu_num_cores());
return Status::OK; return Status::OK;
} }
Status QuitWorker(ServerContext* ctx, const Void*, Void*) GRPC_OVERRIDE { Status QuitWorker(ServerContext* ctx, const Void*, Void*) override {
InstanceGuard g(this); InstanceGuard g(this);
if (!g.Acquired()) { if (!g.Acquired()) {
return Status(StatusCode::RESOURCE_EXHAUSTED, "Quitting worker busy"); return Status(StatusCode::RESOURCE_EXHAUSTED, "Quitting worker busy");

@ -82,10 +82,10 @@ class CompositeReporter : public Reporter {
/** Adds a \a reporter to the composite. */ /** Adds a \a reporter to the composite. */
void add(std::unique_ptr<Reporter> reporter); void add(std::unique_ptr<Reporter> reporter);
void ReportQPS(const ScenarioResult& result) GRPC_OVERRIDE; void ReportQPS(const ScenarioResult& result) override;
void ReportQPSPerCore(const ScenarioResult& result) GRPC_OVERRIDE; void ReportQPSPerCore(const ScenarioResult& result) override;
void ReportLatency(const ScenarioResult& result) GRPC_OVERRIDE; void ReportLatency(const ScenarioResult& result) override;
void ReportTimes(const ScenarioResult& result) GRPC_OVERRIDE; void ReportTimes(const ScenarioResult& result) override;
private: private:
std::vector<std::unique_ptr<Reporter> > reporters_; std::vector<std::unique_ptr<Reporter> > reporters_;
@ -97,10 +97,10 @@ class GprLogReporter : public Reporter {
GprLogReporter(const string& name) : Reporter(name) {} GprLogReporter(const string& name) : Reporter(name) {}
private: private:
void ReportQPS(const ScenarioResult& result) GRPC_OVERRIDE; void ReportQPS(const ScenarioResult& result) override;
void ReportQPSPerCore(const ScenarioResult& result) GRPC_OVERRIDE; void ReportQPSPerCore(const ScenarioResult& result) override;
void ReportLatency(const ScenarioResult& result) GRPC_OVERRIDE; void ReportLatency(const ScenarioResult& result) override;
void ReportTimes(const ScenarioResult& result) GRPC_OVERRIDE; void ReportTimes(const ScenarioResult& result) override;
}; };
/** Dumps the report to a JSON file. */ /** Dumps the report to a JSON file. */
@ -110,10 +110,10 @@ class JsonReporter : public Reporter {
: Reporter(name), report_file_(report_file) {} : Reporter(name), report_file_(report_file) {}
private: private:
void ReportQPS(const ScenarioResult& result) GRPC_OVERRIDE; void ReportQPS(const ScenarioResult& result) override;
void ReportQPSPerCore(const ScenarioResult& result) GRPC_OVERRIDE; void ReportQPSPerCore(const ScenarioResult& result) override;
void ReportLatency(const ScenarioResult& result) GRPC_OVERRIDE; void ReportLatency(const ScenarioResult& result) override;
void ReportTimes(const ScenarioResult& result) GRPC_OVERRIDE; void ReportTimes(const ScenarioResult& result) override;
const string report_file_; const string report_file_;
}; };

@ -58,7 +58,7 @@ namespace testing {
template <class RequestType, class ResponseType, class ServiceType, template <class RequestType, class ResponseType, class ServiceType,
class ServerContextType> class ServerContextType>
class AsyncQpsServerTest GRPC_FINAL : public grpc::testing::Server { class AsyncQpsServerTest final : public grpc::testing::Server {
public: public:
AsyncQpsServerTest( AsyncQpsServerTest(
const ServerConfig &config, const ServerConfig &config,
@ -196,7 +196,7 @@ class AsyncQpsServerTest GRPC_FINAL : public grpc::testing::Server {
return reinterpret_cast<ServerRpcContext *>(tag); return reinterpret_cast<ServerRpcContext *>(tag);
} }
class ServerRpcContextUnaryImpl GRPC_FINAL : public ServerRpcContext { class ServerRpcContextUnaryImpl final : public ServerRpcContext {
public: public:
ServerRpcContextUnaryImpl( ServerRpcContextUnaryImpl(
std::function<void(ServerContextType *, RequestType *, std::function<void(ServerContextType *, RequestType *,
@ -213,11 +213,9 @@ class AsyncQpsServerTest GRPC_FINAL : public grpc::testing::Server {
request_method_(srv_ctx_.get(), &req_, &response_writer_, request_method_(srv_ctx_.get(), &req_, &response_writer_,
AsyncQpsServerTest::tag(this)); AsyncQpsServerTest::tag(this));
} }
~ServerRpcContextUnaryImpl() GRPC_OVERRIDE {} ~ServerRpcContextUnaryImpl() override {}
bool RunNextState(bool ok) GRPC_OVERRIDE { bool RunNextState(bool ok) override { return (this->*next_state_)(ok); }
return (this->*next_state_)(ok); void Reset() override {
}
void Reset() GRPC_OVERRIDE {
srv_ctx_.reset(new ServerContextType); srv_ctx_.reset(new ServerContextType);
req_ = RequestType(); req_ = RequestType();
response_writer_ = response_writer_ =
@ -257,7 +255,7 @@ class AsyncQpsServerTest GRPC_FINAL : public grpc::testing::Server {
grpc::ServerAsyncResponseWriter<ResponseType> response_writer_; grpc::ServerAsyncResponseWriter<ResponseType> response_writer_;
}; };
class ServerRpcContextStreamingImpl GRPC_FINAL : public ServerRpcContext { class ServerRpcContextStreamingImpl final : public ServerRpcContext {
public: public:
ServerRpcContextStreamingImpl( ServerRpcContextStreamingImpl(
std::function<void( std::function<void(
@ -273,11 +271,9 @@ class AsyncQpsServerTest GRPC_FINAL : public grpc::testing::Server {
stream_(srv_ctx_.get()) { stream_(srv_ctx_.get()) {
request_method_(srv_ctx_.get(), &stream_, AsyncQpsServerTest::tag(this)); request_method_(srv_ctx_.get(), &stream_, AsyncQpsServerTest::tag(this));
} }
~ServerRpcContextStreamingImpl() GRPC_OVERRIDE {} ~ServerRpcContextStreamingImpl() override {}
bool RunNextState(bool ok) GRPC_OVERRIDE { bool RunNextState(bool ok) override { return (this->*next_state_)(ok); }
return (this->*next_state_)(ok); void Reset() override {
}
void Reset() GRPC_OVERRIDE {
srv_ctx_.reset(new ServerContextType); srv_ctx_.reset(new ServerContextType);
req_ = RequestType(); req_ = RequestType();
stream_ = grpc::ServerAsyncReaderWriter<ResponseType, RequestType>( stream_ = grpc::ServerAsyncReaderWriter<ResponseType, RequestType>(

@ -48,10 +48,10 @@
namespace grpc { namespace grpc {
namespace testing { namespace testing {
class BenchmarkServiceImpl GRPC_FINAL : public BenchmarkService::Service { class BenchmarkServiceImpl final : public BenchmarkService::Service {
public: public:
Status UnaryCall(ServerContext* context, const SimpleRequest* request, Status UnaryCall(ServerContext* context, const SimpleRequest* request,
SimpleResponse* response) GRPC_OVERRIDE { SimpleResponse* response) override {
if (request->response_size() > 0) { if (request->response_size() > 0) {
if (!Server::SetPayload(request->response_type(), if (!Server::SetPayload(request->response_type(),
request->response_size(), request->response_size(),
@ -63,7 +63,7 @@ class BenchmarkServiceImpl GRPC_FINAL : public BenchmarkService::Service {
} }
Status StreamingCall( Status StreamingCall(
ServerContext* context, ServerContext* context,
ServerReaderWriter<SimpleResponse, SimpleRequest>* stream) GRPC_OVERRIDE { ServerReaderWriter<SimpleResponse, SimpleRequest>* stream) override {
SimpleRequest request; SimpleRequest request;
while (stream->Read(&request)) { while (stream->Read(&request)) {
SimpleResponse response; SimpleResponse response;
@ -80,7 +80,7 @@ class BenchmarkServiceImpl GRPC_FINAL : public BenchmarkService::Service {
} }
}; };
class SynchronousServer GRPC_FINAL : public grpc::testing::Server { class SynchronousServer final : public grpc::testing::Server {
public: public:
explicit SynchronousServer(const ServerConfig& config) : Server(config) { explicit SynchronousServer(const ServerConfig& config) : Server(config) {
ServerBuilder builder; ServerBuilder builder;

@ -43,7 +43,7 @@
#include "test/cpp/util/test_config.h" #include "test/cpp/util/test_config.h"
namespace grpc { namespace grpc {
class ThreadManagerTest GRPC_FINAL : public grpc::ThreadManager { class ThreadManagerTest final : public grpc::ThreadManager {
public: public:
ThreadManagerTest() ThreadManagerTest()
: ThreadManager(kMinPollers, kMaxPollers), : ThreadManager(kMinPollers, kMaxPollers),
@ -51,9 +51,8 @@ class ThreadManagerTest GRPC_FINAL : public grpc::ThreadManager {
num_poll_for_work_(0), num_poll_for_work_(0),
num_work_found_(0) {} num_work_found_(0) {}
grpc::ThreadManager::WorkStatus PollForWork(void **tag, grpc::ThreadManager::WorkStatus PollForWork(void **tag, bool *ok) override;
bool *ok) GRPC_OVERRIDE; void DoWork(void *tag, bool ok) override;
void DoWork(void *tag, bool ok) GRPC_OVERRIDE;
void PerformTest(); void PerformTest();
private: private:

@ -43,7 +43,7 @@
namespace grpc { namespace grpc {
namespace testing { namespace testing {
class CliCall GRPC_FINAL { class CliCall final {
public: public:
typedef std::multimap<grpc::string, grpc::string> OutgoingMetadataContainer; typedef std::multimap<grpc::string, grpc::string> OutgoingMetadataContainer;
typedef std::multimap<grpc::string_ref, grpc::string_ref> typedef std::multimap<grpc::string_ref, grpc::string_ref>

@ -56,7 +56,7 @@ namespace testing {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
if (!context->client_metadata().empty()) { if (!context->client_metadata().empty()) {
for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
iter = context->client_metadata().begin(); iter = context->client_metadata().begin();
@ -75,7 +75,7 @@ class CliCallTest : public ::testing::Test {
protected: protected:
CliCallTest() {} CliCallTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port; server_address_ << "localhost:" << port;
// Setup server // Setup server
@ -86,7 +86,7 @@ class CliCallTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void TearDown() override { server_->Shutdown(); }
void ResetStub() { void ResetStub() {
channel_ = channel_ =

@ -93,13 +93,12 @@ DECLARE_bool(l);
namespace { namespace {
class TestCliCredentials GRPC_FINAL : public grpc::testing::CliCredentials { class TestCliCredentials final : public grpc::testing::CliCredentials {
public: public:
std::shared_ptr<grpc::ChannelCredentials> GetCredentials() const std::shared_ptr<grpc::ChannelCredentials> GetCredentials() const override {
GRPC_OVERRIDE {
return InsecureChannelCredentials(); return InsecureChannelCredentials();
} }
const grpc::string GetCredentialUsage() const GRPC_OVERRIDE { return ""; } const grpc::string GetCredentialUsage() const override { return ""; }
}; };
bool PrintStream(std::stringstream* ss, const grpc::string& output) { bool PrintStream(std::stringstream* ss, const grpc::string& output) {
@ -118,7 +117,7 @@ size_t ArraySize(T& a) {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service { class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
if (!context->client_metadata().empty()) { if (!context->client_metadata().empty()) {
for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
iter = context->client_metadata().begin(); iter = context->client_metadata().begin();

@ -83,13 +83,13 @@ class QpsGauge {
std::mutex num_queries_mu_; std::mutex num_queries_mu_;
}; };
class MetricsServiceImpl GRPC_FINAL : public MetricsService::Service { class MetricsServiceImpl final : public MetricsService::Service {
public: public:
grpc::Status GetAllGauges(ServerContext* context, const EmptyMessage* request, grpc::Status GetAllGauges(ServerContext* context, const EmptyMessage* request,
ServerWriter<GaugeResponse>* writer) GRPC_OVERRIDE; ServerWriter<GaugeResponse>* writer) override;
grpc::Status GetGauge(ServerContext* context, const GaugeRequest* request, grpc::Status GetGauge(ServerContext* context, const GaugeRequest* request,
GaugeResponse* response) GRPC_OVERRIDE; GaugeResponse* response) override;
// Create a QpsGauge with name 'name'. is_present is set to true if the Gauge // Create a QpsGauge with name 'name'. is_present is set to true if the Gauge
// is already present in the map. // is already present in the map.

@ -61,7 +61,7 @@ class ErrorPrinter : public protobuf::compiler::MultiFileErrorCollector {
explicit ErrorPrinter(ProtoFileParser* parser) : parser_(parser) {} explicit ErrorPrinter(ProtoFileParser* parser) : parser_(parser) {}
void AddError(const grpc::string& filename, int line, int column, void AddError(const grpc::string& filename, int line, int column,
const grpc::string& message) GRPC_OVERRIDE { const grpc::string& message) override {
std::ostringstream oss; std::ostringstream oss;
oss << "error " << filename << " " << line << " " << column << " " oss << "error " << filename << " " << line << " " << column << " "
<< message << "\n"; << message << "\n";
@ -69,7 +69,7 @@ class ErrorPrinter : public protobuf::compiler::MultiFileErrorCollector {
} }
void AddWarning(const grpc::string& filename, int line, int column, void AddWarning(const grpc::string& filename, int line, int column,
const grpc::string& message) GRPC_OVERRIDE { const grpc::string& message) override {
std::cerr << "warning " << filename << " " << line << " " << column << " " std::cerr << "warning " << filename << " " << line << " " << column << " "
<< message << std::endl; << message << std::endl;
} }

@ -62,14 +62,13 @@ class ProtoReflectionDescriptorDatabase : public protobuf::DescriptorDatabase {
// Find a file by file name. Fills in in *output and returns true if found. // Find a file by file name. Fills in in *output and returns true if found.
// Otherwise, returns false, leaving the contents of *output undefined. // Otherwise, returns false, leaving the contents of *output undefined.
bool FindFileByName(const string& filename, bool FindFileByName(const string& filename,
protobuf::FileDescriptorProto* output) GRPC_OVERRIDE; protobuf::FileDescriptorProto* output) override;
// Find the file that declares the given fully-qualified symbol name. // Find the file that declares the given fully-qualified symbol name.
// If found, fills in *output and returns true, otherwise returns false // If found, fills in *output and returns true, otherwise returns false
// and leaves *output undefined. // and leaves *output undefined.
bool FindFileContainingSymbol(const string& symbol_name, bool FindFileContainingSymbol(const string& symbol_name,
protobuf::FileDescriptorProto* output) protobuf::FileDescriptorProto* output) override;
GRPC_OVERRIDE;
// Find the file which defines an extension extending the given message type // Find the file which defines an extension extending the given message type
// with the given field number. If found, fills in *output and returns true, // with the given field number. If found, fills in *output and returns true,
@ -77,7 +76,7 @@ class ProtoReflectionDescriptorDatabase : public protobuf::DescriptorDatabase {
// must be a fully-qualified type name. // must be a fully-qualified type name.
bool FindFileContainingExtension( bool FindFileContainingExtension(
const string& containing_type, int field_number, const string& containing_type, int field_number,
protobuf::FileDescriptorProto* output) GRPC_OVERRIDE; protobuf::FileDescriptorProto* output) override;
// Finds the tag numbers used by all known extensions of // Finds the tag numbers used by all known extensions of
// extendee_type, and appends them to output in an undefined // extendee_type, and appends them to output in an undefined
@ -87,7 +86,7 @@ class ProtoReflectionDescriptorDatabase : public protobuf::DescriptorDatabase {
// numbers. Returns true if the search was successful, otherwise // numbers. Returns true if the search was successful, otherwise
// returns false and leaves output unchanged. // returns false and leaves output unchanged.
bool FindAllExtensionNumbers(const string& extendee_type, bool FindAllExtensionNumbers(const string& extendee_type,
std::vector<int>* output) GRPC_OVERRIDE; std::vector<int>* output) override;
// Provide a list of full names of registered services // Provide a list of full names of registered services
bool GetServices(std::vector<grpc::string>* output); bool GetServices(std::vector<grpc::string>* output);

@ -34,9 +34,9 @@
#include "test/cpp/util/test_credentials_provider.h" #include "test/cpp/util/test_credentials_provider.h"
#include <mutex>
#include <unordered_map> #include <unordered_map>
#include <grpc++/impl/sync.h>
#include <grpc/support/log.h> #include <grpc/support/log.h>
#include <grpc/support/sync.h> #include <grpc/support/sync.h>
@ -64,14 +64,14 @@ class CredentialsProvider {
class DefaultCredentialsProvider : public CredentialsProvider { class DefaultCredentialsProvider : public CredentialsProvider {
public: public:
~DefaultCredentialsProvider() GRPC_OVERRIDE {} ~DefaultCredentialsProvider() override {}
void AddSecureType(const grpc::string& type, void AddSecureType(
std::unique_ptr<CredentialTypeProvider> type_provider) const grpc::string& type,
GRPC_OVERRIDE { std::unique_ptr<CredentialTypeProvider> type_provider) override {
// This clobbers any existing entry for type, except the defaults, which // This clobbers any existing entry for type, except the defaults, which
// can't be clobbered. // can't be clobbered.
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
auto it = std::find(added_secure_type_names_.begin(), auto it = std::find(added_secure_type_names_.begin(),
added_secure_type_names_.end(), type); added_secure_type_names_.end(), type);
if (it == added_secure_type_names_.end()) { if (it == added_secure_type_names_.end()) {
@ -84,7 +84,7 @@ class DefaultCredentialsProvider : public CredentialsProvider {
} }
std::shared_ptr<ChannelCredentials> GetChannelCredentials( std::shared_ptr<ChannelCredentials> GetChannelCredentials(
const grpc::string& type, ChannelArguments* args) GRPC_OVERRIDE { const grpc::string& type, ChannelArguments* args) override {
if (type == grpc::testing::kInsecureCredentialsType) { if (type == grpc::testing::kInsecureCredentialsType) {
return InsecureChannelCredentials(); return InsecureChannelCredentials();
} else if (type == grpc::testing::kTlsCredentialsType) { } else if (type == grpc::testing::kTlsCredentialsType) {
@ -92,7 +92,7 @@ class DefaultCredentialsProvider : public CredentialsProvider {
args->SetSslTargetNameOverride("foo.test.google.fr"); args->SetSslTargetNameOverride("foo.test.google.fr");
return SslCredentials(ssl_opts); return SslCredentials(ssl_opts);
} else { } else {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
auto it(std::find(added_secure_type_names_.begin(), auto it(std::find(added_secure_type_names_.begin(),
added_secure_type_names_.end(), type)); added_secure_type_names_.end(), type));
if (it == added_secure_type_names_.end()) { if (it == added_secure_type_names_.end()) {
@ -105,7 +105,7 @@ class DefaultCredentialsProvider : public CredentialsProvider {
} }
std::shared_ptr<ServerCredentials> GetServerCredentials( std::shared_ptr<ServerCredentials> GetServerCredentials(
const grpc::string& type) GRPC_OVERRIDE { const grpc::string& type) override {
if (type == grpc::testing::kInsecureCredentialsType) { if (type == grpc::testing::kInsecureCredentialsType) {
return InsecureServerCredentials(); return InsecureServerCredentials();
} else if (type == grpc::testing::kTlsCredentialsType) { } else if (type == grpc::testing::kTlsCredentialsType) {
@ -116,7 +116,7 @@ class DefaultCredentialsProvider : public CredentialsProvider {
ssl_opts.pem_key_cert_pairs.push_back(pkcp); ssl_opts.pem_key_cert_pairs.push_back(pkcp);
return SslServerCredentials(ssl_opts); return SslServerCredentials(ssl_opts);
} else { } else {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
auto it(std::find(added_secure_type_names_.begin(), auto it(std::find(added_secure_type_names_.begin(),
added_secure_type_names_.end(), type)); added_secure_type_names_.end(), type));
if (it == added_secure_type_names_.end()) { if (it == added_secure_type_names_.end()) {
@ -127,10 +127,10 @@ class DefaultCredentialsProvider : public CredentialsProvider {
->GetServerCredentials(); ->GetServerCredentials();
} }
} }
std::vector<grpc::string> GetSecureCredentialsTypeList() GRPC_OVERRIDE { std::vector<grpc::string> GetSecureCredentialsTypeList() override {
std::vector<grpc::string> types; std::vector<grpc::string> types;
types.push_back(grpc::testing::kTlsCredentialsType); types.push_back(grpc::testing::kTlsCredentialsType);
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
for (auto it = added_secure_type_names_.begin(); for (auto it = added_secure_type_names_.begin();
it != added_secure_type_names_.end(); it++) { it != added_secure_type_names_.end(); it++) {
types.push_back(*it); types.push_back(*it);
@ -139,7 +139,7 @@ class DefaultCredentialsProvider : public CredentialsProvider {
} }
private: private:
grpc::mutex mu_; std::mutex mu_;
std::vector<grpc::string> added_secure_type_names_; std::vector<grpc::string> added_secure_type_names_;
std::vector<std::unique_ptr<CredentialTypeProvider>> std::vector<std::unique_ptr<CredentialTypeProvider>>
added_secure_type_providers_; added_secure_type_providers_;

@ -781,12 +781,6 @@ include/grpc++/impl/server_builder_option.h \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -834,9 +828,6 @@ include/grpc++/impl/codegen/status_code_enum.h \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \

@ -781,12 +781,6 @@ include/grpc++/impl/server_builder_option.h \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -834,9 +828,6 @@ include/grpc++/impl/codegen/status_code_enum.h \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \

@ -7457,12 +7457,6 @@
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -7515,12 +7509,6 @@
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -7609,9 +7597,6 @@
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h" "include/grpc++/impl/codegen/time.h"
], ],
@ -7645,9 +7630,6 @@
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h" "include/grpc++/impl/codegen/time.h"
], ],

@ -279,12 +279,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_builder_plugin.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_builder_plugin.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_initializer.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_initializer.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_context.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_context.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_metadata_processor.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_metadata_processor.h" />
@ -332,9 +326,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" />

@ -174,24 +174,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h">
<Filter>include\grpc++\impl</Filter> <Filter>include\grpc++\impl</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_no_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_no_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h">
<Filter>include\grpc++</Filter> <Filter>include\grpc++</Filter>
</ClInclude> </ClInclude>
@ -333,15 +315,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>

@ -173,9 +173,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" />

@ -111,15 +111,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>

@ -279,12 +279,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_builder_plugin.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_builder_plugin.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_initializer.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\server_initializer.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_context.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_context.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_metadata_processor.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\security\auth_metadata_processor.h" />
@ -332,9 +326,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" />

@ -159,24 +159,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\service_type.h">
<Filter>include\grpc++\impl</Filter> <Filter>include\grpc++\impl</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\sync_no_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\thd_no_cxx11.h">
<Filter>include\grpc++\impl</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\resource_quota.h">
<Filter>include\grpc++</Filter> <Filter>include\grpc++</Filter>
</ClInclude> </ClInclude>
@ -318,15 +300,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>

@ -186,9 +186,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" />

@ -99,15 +99,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>

@ -186,9 +186,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\status_helper.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\string_ref.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\time.h" />
<ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" /> <ClInclude Include="$(SolutionDir)\..\include\grpc\impl\codegen\byte_buffer_reader.h" />

@ -102,15 +102,6 @@
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\stub_options.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_no_cxx11.h">
<Filter>include\grpc++\impl\codegen</Filter>
</ClInclude>
<ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h"> <ClInclude Include="$(SolutionDir)\..\include\grpc++\impl\codegen\sync_stream.h">
<Filter>include\grpc++\impl\codegen</Filter> <Filter>include\grpc++\impl\codegen</Filter>
</ClInclude> </ClInclude>

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save