Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2016 gRPC authors. |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 4 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 10 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
| 19 | #ifndef GRPC_RB_GRPC_IMPORTS_H_ |
| 20 | #define GRPC_RB_GRPC_IMPORTS_H_ |
| 21 | |
| 22 | #include <grpc/support/port_platform.h> |
| 23 | |
Yuchen Zeng | 12dfdc3 | 2016-04-26 22:05:41 -0700 | [diff] [blame] | 24 | #ifdef GPR_WINDOWS |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 25 | |
| 26 | #include <windows.h> |
| 27 | |
Nicolas "Pixel" Noble | b8e9e9c | 2016-01-30 18:35:13 +0100 | [diff] [blame] | 28 | #include <grpc/compression.h> |
| 29 | #include <grpc/grpc.h> |
Adam Michalik | 321b1fb | 2016-05-16 15:42:36 -0700 | [diff] [blame] | 30 | #include <grpc/grpc_posix.h> |
Nicolas "Pixel" Noble | b8e9e9c | 2016-01-30 18:35:13 +0100 | [diff] [blame] | 31 | #include <grpc/grpc_security.h> |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 32 | #include <grpc/impl/codegen/byte_buffer.h> |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 33 | #include <grpc/slice.h> |
| 34 | #include <grpc/slice_buffer.h> |
David Garcia Quintas | 3b31fdf | 2016-07-27 18:17:12 -0700 | [diff] [blame] | 35 | #include <grpc/support/alloc.h> |
Nicolas "Pixel" Noble | b8e9e9c | 2016-01-30 18:35:13 +0100 | [diff] [blame] | 36 | #include <grpc/support/avl.h> |
| 37 | #include <grpc/support/cmdline.h> |
| 38 | #include <grpc/support/cpu.h> |
| 39 | #include <grpc/support/histogram.h> |
| 40 | #include <grpc/support/host_port.h> |
David Garcia Quintas | c79b065 | 2016-07-27 21:11:58 -0700 | [diff] [blame] | 41 | #include <grpc/support/log.h> |
Yuchen Zeng | 12dfdc3 | 2016-04-26 22:05:41 -0700 | [diff] [blame] | 42 | #include <grpc/support/log_windows.h> |
Nicolas "Pixel" Noble | b8e9e9c | 2016-01-30 18:35:13 +0100 | [diff] [blame] | 43 | #include <grpc/support/string_util.h> |
| 44 | #include <grpc/support/subprocess.h> |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 45 | #include <grpc/support/sync.h> |
Nicolas "Pixel" Noble | b8e9e9c | 2016-01-30 18:35:13 +0100 | [diff] [blame] | 46 | #include <grpc/support/thd.h> |
David Garcia Quintas | 1399e46 | 2016-07-27 20:31:55 -0700 | [diff] [blame] | 47 | #include <grpc/support/time.h> |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 48 | |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 49 | typedef int(*grpc_compression_algorithm_parse_type)(grpc_slice value, grpc_compression_algorithm* algorithm); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 50 | extern grpc_compression_algorithm_parse_type grpc_compression_algorithm_parse_import; |
| 51 | #define grpc_compression_algorithm_parse grpc_compression_algorithm_parse_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 52 | typedef int(*grpc_compression_algorithm_name_type)(grpc_compression_algorithm algorithm, const char** name); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 53 | extern grpc_compression_algorithm_name_type grpc_compression_algorithm_name_import; |
| 54 | #define grpc_compression_algorithm_name grpc_compression_algorithm_name_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 55 | typedef int(*grpc_stream_compression_algorithm_name_type)(grpc_stream_compression_algorithm algorithm, const char** name); |
Muxi Yan | b32c23a | 2017-07-26 14:49:53 -0700 | [diff] [blame] | 56 | extern grpc_stream_compression_algorithm_name_type grpc_stream_compression_algorithm_name_import; |
| 57 | #define grpc_stream_compression_algorithm_name grpc_stream_compression_algorithm_name_import |
David Garcia Quintas | a36ec16 | 2016-03-18 10:00:23 -0700 | [diff] [blame] | 58 | typedef grpc_compression_algorithm(*grpc_compression_algorithm_for_level_type)(grpc_compression_level level, uint32_t accepted_encodings); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 59 | extern grpc_compression_algorithm_for_level_type grpc_compression_algorithm_for_level_import; |
| 60 | #define grpc_compression_algorithm_for_level grpc_compression_algorithm_for_level_import |
Muxi Yan | b32c23a | 2017-07-26 14:49:53 -0700 | [diff] [blame] | 61 | typedef grpc_stream_compression_algorithm(*grpc_stream_compression_algorithm_for_level_type)(grpc_stream_compression_level level, uint32_t accepted_stream_encodings); |
| 62 | extern grpc_stream_compression_algorithm_for_level_type grpc_stream_compression_algorithm_for_level_import; |
| 63 | #define grpc_stream_compression_algorithm_for_level grpc_stream_compression_algorithm_for_level_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 64 | typedef void(*grpc_compression_options_init_type)(grpc_compression_options* opts); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 65 | extern grpc_compression_options_init_type grpc_compression_options_init_import; |
| 66 | #define grpc_compression_options_init grpc_compression_options_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 67 | typedef void(*grpc_compression_options_enable_algorithm_type)(grpc_compression_options* opts, grpc_compression_algorithm algorithm); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 68 | extern grpc_compression_options_enable_algorithm_type grpc_compression_options_enable_algorithm_import; |
| 69 | #define grpc_compression_options_enable_algorithm grpc_compression_options_enable_algorithm_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 70 | typedef void(*grpc_compression_options_disable_algorithm_type)(grpc_compression_options* opts, grpc_compression_algorithm algorithm); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 71 | extern grpc_compression_options_disable_algorithm_type grpc_compression_options_disable_algorithm_import; |
| 72 | #define grpc_compression_options_disable_algorithm grpc_compression_options_disable_algorithm_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 73 | typedef int(*grpc_compression_options_is_algorithm_enabled_type)(const grpc_compression_options* opts, grpc_compression_algorithm algorithm); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 74 | extern grpc_compression_options_is_algorithm_enabled_type grpc_compression_options_is_algorithm_enabled_import; |
| 75 | #define grpc_compression_options_is_algorithm_enabled grpc_compression_options_is_algorithm_enabled_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 76 | typedef int(*grpc_compression_options_is_stream_compression_algorithm_enabled_type)(const grpc_compression_options* opts, grpc_stream_compression_algorithm algorithm); |
Muxi Yan | b32c23a | 2017-07-26 14:49:53 -0700 | [diff] [blame] | 77 | extern grpc_compression_options_is_stream_compression_algorithm_enabled_type grpc_compression_options_is_stream_compression_algorithm_enabled_import; |
| 78 | #define grpc_compression_options_is_stream_compression_algorithm_enabled grpc_compression_options_is_stream_compression_algorithm_enabled_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 79 | typedef void(*grpc_metadata_array_init_type)(grpc_metadata_array* array); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 80 | extern grpc_metadata_array_init_type grpc_metadata_array_init_import; |
| 81 | #define grpc_metadata_array_init grpc_metadata_array_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 82 | typedef void(*grpc_metadata_array_destroy_type)(grpc_metadata_array* array); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 83 | extern grpc_metadata_array_destroy_type grpc_metadata_array_destroy_import; |
| 84 | #define grpc_metadata_array_destroy grpc_metadata_array_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 85 | typedef void(*grpc_call_details_init_type)(grpc_call_details* details); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 86 | extern grpc_call_details_init_type grpc_call_details_init_import; |
| 87 | #define grpc_call_details_init grpc_call_details_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 88 | typedef void(*grpc_call_details_destroy_type)(grpc_call_details* details); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 89 | extern grpc_call_details_destroy_type grpc_call_details_destroy_import; |
| 90 | #define grpc_call_details_destroy grpc_call_details_destroy_import |
| 91 | typedef void(*grpc_register_plugin_type)(void (*init)(void), void (*destroy)(void)); |
| 92 | extern grpc_register_plugin_type grpc_register_plugin_import; |
| 93 | #define grpc_register_plugin grpc_register_plugin_import |
| 94 | typedef void(*grpc_init_type)(void); |
| 95 | extern grpc_init_type grpc_init_import; |
| 96 | #define grpc_init grpc_init_import |
| 97 | typedef void(*grpc_shutdown_type)(void); |
| 98 | extern grpc_shutdown_type grpc_shutdown_import; |
| 99 | #define grpc_shutdown grpc_shutdown_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 100 | typedef const char*(*grpc_version_string_type)(void); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 101 | extern grpc_version_string_type grpc_version_string_import; |
| 102 | #define grpc_version_string grpc_version_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 103 | typedef const char*(*grpc_g_stands_for_type)(void); |
Craig Tiller | d9f9076 | 2016-08-29 16:47:22 -0700 | [diff] [blame] | 104 | extern grpc_g_stands_for_type grpc_g_stands_for_import; |
| 105 | #define grpc_g_stands_for grpc_g_stands_for_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 106 | typedef const grpc_completion_queue_factory*(*grpc_completion_queue_factory_lookup_type)(const grpc_completion_queue_attributes* attributes); |
Sree Kuchibhotla | bf18428 | 2017-03-21 15:18:58 -0700 | [diff] [blame] | 107 | extern grpc_completion_queue_factory_lookup_type grpc_completion_queue_factory_lookup_import; |
| 108 | #define grpc_completion_queue_factory_lookup grpc_completion_queue_factory_lookup_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 109 | typedef grpc_completion_queue*(*grpc_completion_queue_create_for_next_type)(void* reserved); |
Sree Kuchibhotla | bf18428 | 2017-03-21 15:18:58 -0700 | [diff] [blame] | 110 | extern grpc_completion_queue_create_for_next_type grpc_completion_queue_create_for_next_import; |
| 111 | #define grpc_completion_queue_create_for_next grpc_completion_queue_create_for_next_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 112 | typedef grpc_completion_queue*(*grpc_completion_queue_create_for_pluck_type)(void* reserved); |
Sree Kuchibhotla | bf18428 | 2017-03-21 15:18:58 -0700 | [diff] [blame] | 113 | extern grpc_completion_queue_create_for_pluck_type grpc_completion_queue_create_for_pluck_import; |
| 114 | #define grpc_completion_queue_create_for_pluck grpc_completion_queue_create_for_pluck_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 115 | typedef grpc_completion_queue*(*grpc_completion_queue_create_type)(const grpc_completion_queue_factory* factory, const grpc_completion_queue_attributes* attributes, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 116 | extern grpc_completion_queue_create_type grpc_completion_queue_create_import; |
| 117 | #define grpc_completion_queue_create grpc_completion_queue_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 118 | typedef grpc_event(*grpc_completion_queue_next_type)(grpc_completion_queue* cq, gpr_timespec deadline, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 119 | extern grpc_completion_queue_next_type grpc_completion_queue_next_import; |
| 120 | #define grpc_completion_queue_next grpc_completion_queue_next_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 121 | typedef grpc_event(*grpc_completion_queue_pluck_type)(grpc_completion_queue* cq, void* tag, gpr_timespec deadline, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 122 | extern grpc_completion_queue_pluck_type grpc_completion_queue_pluck_import; |
| 123 | #define grpc_completion_queue_pluck grpc_completion_queue_pluck_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 124 | typedef void(*grpc_completion_queue_shutdown_type)(grpc_completion_queue* cq); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 125 | extern grpc_completion_queue_shutdown_type grpc_completion_queue_shutdown_import; |
| 126 | #define grpc_completion_queue_shutdown grpc_completion_queue_shutdown_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 127 | typedef void(*grpc_completion_queue_destroy_type)(grpc_completion_queue* cq); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 128 | extern grpc_completion_queue_destroy_type grpc_completion_queue_destroy_import; |
| 129 | #define grpc_completion_queue_destroy grpc_completion_queue_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 130 | typedef void(*grpc_completion_queue_thread_local_cache_init_type)(grpc_completion_queue* cq); |
Ken Payson | 42bd87e | 2017-10-20 10:32:30 -0700 | [diff] [blame] | 131 | extern grpc_completion_queue_thread_local_cache_init_type grpc_completion_queue_thread_local_cache_init_import; |
| 132 | #define grpc_completion_queue_thread_local_cache_init grpc_completion_queue_thread_local_cache_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 133 | typedef int(*grpc_completion_queue_thread_local_cache_flush_type)(grpc_completion_queue* cq, void** tag, int* ok); |
Ken Payson | 42bd87e | 2017-10-20 10:32:30 -0700 | [diff] [blame] | 134 | extern grpc_completion_queue_thread_local_cache_flush_type grpc_completion_queue_thread_local_cache_flush_import; |
| 135 | #define grpc_completion_queue_thread_local_cache_flush grpc_completion_queue_thread_local_cache_flush_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 136 | typedef grpc_alarm*(*grpc_alarm_create_type)(void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 137 | extern grpc_alarm_create_type grpc_alarm_create_import; |
| 138 | #define grpc_alarm_create grpc_alarm_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 139 | typedef void(*grpc_alarm_set_type)(grpc_alarm* alarm, grpc_completion_queue* cq, gpr_timespec deadline, void* tag, void* reserved); |
Vijay Pai | 58c33ba | 2017-09-01 14:08:42 -0700 | [diff] [blame] | 140 | extern grpc_alarm_set_type grpc_alarm_set_import; |
| 141 | #define grpc_alarm_set grpc_alarm_set_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 142 | typedef void(*grpc_alarm_cancel_type)(grpc_alarm* alarm, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 143 | extern grpc_alarm_cancel_type grpc_alarm_cancel_import; |
| 144 | #define grpc_alarm_cancel grpc_alarm_cancel_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 145 | typedef void(*grpc_alarm_destroy_type)(grpc_alarm* alarm, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 146 | extern grpc_alarm_destroy_type grpc_alarm_destroy_import; |
| 147 | #define grpc_alarm_destroy grpc_alarm_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 148 | typedef grpc_connectivity_state(*grpc_channel_check_connectivity_state_type)(grpc_channel* channel, int try_to_connect); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 149 | extern grpc_channel_check_connectivity_state_type grpc_channel_check_connectivity_state_import; |
| 150 | #define grpc_channel_check_connectivity_state grpc_channel_check_connectivity_state_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 151 | typedef int(*grpc_channel_num_external_connectivity_watchers_type)(grpc_channel* channel); |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 152 | extern grpc_channel_num_external_connectivity_watchers_type grpc_channel_num_external_connectivity_watchers_import; |
| 153 | #define grpc_channel_num_external_connectivity_watchers grpc_channel_num_external_connectivity_watchers_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 154 | typedef void(*grpc_channel_watch_connectivity_state_type)(grpc_channel* channel, grpc_connectivity_state last_observed_state, gpr_timespec deadline, grpc_completion_queue* cq, void* tag); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 155 | extern grpc_channel_watch_connectivity_state_type grpc_channel_watch_connectivity_state_import; |
| 156 | #define grpc_channel_watch_connectivity_state grpc_channel_watch_connectivity_state_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 157 | typedef int(*grpc_channel_support_connectivity_watcher_type)(grpc_channel* channel); |
Yuchen Zeng | ba23e79 | 2017-08-24 23:13:09 -0700 | [diff] [blame] | 158 | extern grpc_channel_support_connectivity_watcher_type grpc_channel_support_connectivity_watcher_import; |
| 159 | #define grpc_channel_support_connectivity_watcher grpc_channel_support_connectivity_watcher_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 160 | typedef grpc_call*(*grpc_channel_create_call_type)(grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_completion_queue* completion_queue, grpc_slice method, const grpc_slice* host, gpr_timespec deadline, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 161 | extern grpc_channel_create_call_type grpc_channel_create_call_import; |
| 162 | #define grpc_channel_create_call grpc_channel_create_call_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 163 | typedef void(*grpc_channel_ping_type)(grpc_channel* channel, grpc_completion_queue* cq, void* tag, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 164 | extern grpc_channel_ping_type grpc_channel_ping_import; |
| 165 | #define grpc_channel_ping grpc_channel_ping_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 166 | typedef void*(*grpc_channel_register_call_type)(grpc_channel* channel, const char* method, const char* host, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 167 | extern grpc_channel_register_call_type grpc_channel_register_call_import; |
| 168 | #define grpc_channel_register_call grpc_channel_register_call_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 169 | typedef grpc_call*(*grpc_channel_create_registered_call_type)(grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_completion_queue* completion_queue, void* registered_call_handle, gpr_timespec deadline, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 170 | extern grpc_channel_create_registered_call_type grpc_channel_create_registered_call_import; |
| 171 | #define grpc_channel_create_registered_call grpc_channel_create_registered_call_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 172 | typedef void*(*grpc_call_arena_alloc_type)(grpc_call* call, size_t size); |
Vijay Pai | c0e6701 | 2017-03-17 20:00:55 -0700 | [diff] [blame] | 173 | extern grpc_call_arena_alloc_type grpc_call_arena_alloc_import; |
| 174 | #define grpc_call_arena_alloc grpc_call_arena_alloc_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 175 | typedef grpc_call_error(*grpc_call_start_batch_type)(grpc_call* call, const grpc_op* ops, size_t nops, void* tag, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 176 | extern grpc_call_start_batch_type grpc_call_start_batch_import; |
| 177 | #define grpc_call_start_batch grpc_call_start_batch_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 178 | typedef char*(*grpc_call_get_peer_type)(grpc_call* call); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 179 | extern grpc_call_get_peer_type grpc_call_get_peer_import; |
| 180 | #define grpc_call_get_peer grpc_call_get_peer_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 181 | typedef void(*grpc_census_call_set_context_type)(grpc_call* call, struct census_context* context); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 182 | extern grpc_census_call_set_context_type grpc_census_call_set_context_import; |
| 183 | #define grpc_census_call_set_context grpc_census_call_set_context_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 184 | typedef struct census_context*(*grpc_census_call_get_context_type)(grpc_call* call); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 185 | extern grpc_census_call_get_context_type grpc_census_call_get_context_import; |
| 186 | #define grpc_census_call_get_context grpc_census_call_get_context_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 187 | typedef char*(*grpc_channel_get_target_type)(grpc_channel* channel); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 188 | extern grpc_channel_get_target_type grpc_channel_get_target_import; |
| 189 | #define grpc_channel_get_target grpc_channel_get_target_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 190 | typedef void(*grpc_channel_get_info_type)(grpc_channel* channel, const grpc_channel_info* channel_info); |
Mark D. Roth | 8e2d8d9 | 2016-11-04 12:55:07 -0700 | [diff] [blame] | 191 | extern grpc_channel_get_info_type grpc_channel_get_info_import; |
| 192 | #define grpc_channel_get_info grpc_channel_get_info_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 193 | typedef grpc_channel*(*grpc_insecure_channel_create_type)(const char* target, const grpc_channel_args* args, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 194 | extern grpc_insecure_channel_create_type grpc_insecure_channel_create_import; |
| 195 | #define grpc_insecure_channel_create grpc_insecure_channel_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 196 | typedef grpc_channel*(*grpc_lame_client_channel_create_type)(const char* target, grpc_status_code error_code, const char* error_message); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 197 | extern grpc_lame_client_channel_create_type grpc_lame_client_channel_create_import; |
| 198 | #define grpc_lame_client_channel_create grpc_lame_client_channel_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 199 | typedef void(*grpc_channel_destroy_type)(grpc_channel* channel); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 200 | extern grpc_channel_destroy_type grpc_channel_destroy_import; |
| 201 | #define grpc_channel_destroy grpc_channel_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 202 | typedef grpc_call_error(*grpc_call_cancel_type)(grpc_call* call, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 203 | extern grpc_call_cancel_type grpc_call_cancel_import; |
| 204 | #define grpc_call_cancel grpc_call_cancel_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 205 | typedef grpc_call_error(*grpc_call_cancel_with_status_type)(grpc_call* call, grpc_status_code status, const char* description, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 206 | extern grpc_call_cancel_with_status_type grpc_call_cancel_with_status_import; |
| 207 | #define grpc_call_cancel_with_status grpc_call_cancel_with_status_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 208 | typedef void(*grpc_call_ref_type)(grpc_call* call); |
Craig Tiller | d35bb9e | 2017-03-31 12:56:15 -0700 | [diff] [blame] | 209 | extern grpc_call_ref_type grpc_call_ref_import; |
| 210 | #define grpc_call_ref grpc_call_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 211 | typedef void(*grpc_call_unref_type)(grpc_call* call); |
Craig Tiller | dd36b15 | 2017-03-31 08:27:28 -0700 | [diff] [blame] | 212 | extern grpc_call_unref_type grpc_call_unref_import; |
| 213 | #define grpc_call_unref grpc_call_unref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 214 | typedef grpc_call_error(*grpc_server_request_call_type)(grpc_server* server, grpc_call** call, grpc_call_details* details, grpc_metadata_array* request_metadata, grpc_completion_queue* cq_bound_to_call, grpc_completion_queue* cq_for_notification, void* tag_new); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 215 | extern grpc_server_request_call_type grpc_server_request_call_import; |
| 216 | #define grpc_server_request_call grpc_server_request_call_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 217 | typedef void*(*grpc_server_register_method_type)(grpc_server* server, const char* method, const char* host, grpc_server_register_method_payload_handling payload_handling, uint32_t flags); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 218 | extern grpc_server_register_method_type grpc_server_register_method_import; |
| 219 | #define grpc_server_register_method grpc_server_register_method_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 220 | typedef grpc_call_error(*grpc_server_request_registered_call_type)(grpc_server* server, void* registered_method, grpc_call** call, gpr_timespec* deadline, grpc_metadata_array* request_metadata, grpc_byte_buffer** optional_payload, grpc_completion_queue* cq_bound_to_call, grpc_completion_queue* cq_for_notification, void* tag_new); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 221 | extern grpc_server_request_registered_call_type grpc_server_request_registered_call_import; |
| 222 | #define grpc_server_request_registered_call grpc_server_request_registered_call_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 223 | typedef grpc_server*(*grpc_server_create_type)(const grpc_channel_args* args, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 224 | extern grpc_server_create_type grpc_server_create_import; |
| 225 | #define grpc_server_create grpc_server_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 226 | typedef void(*grpc_server_register_completion_queue_type)(grpc_server* server, grpc_completion_queue* cq, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 227 | extern grpc_server_register_completion_queue_type grpc_server_register_completion_queue_import; |
| 228 | #define grpc_server_register_completion_queue grpc_server_register_completion_queue_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 229 | typedef int(*grpc_server_add_insecure_http2_port_type)(grpc_server* server, const char* addr); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 230 | extern grpc_server_add_insecure_http2_port_type grpc_server_add_insecure_http2_port_import; |
| 231 | #define grpc_server_add_insecure_http2_port grpc_server_add_insecure_http2_port_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 232 | typedef void(*grpc_server_start_type)(grpc_server* server); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 233 | extern grpc_server_start_type grpc_server_start_import; |
| 234 | #define grpc_server_start grpc_server_start_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 235 | typedef void(*grpc_server_shutdown_and_notify_type)(grpc_server* server, grpc_completion_queue* cq, void* tag); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 236 | extern grpc_server_shutdown_and_notify_type grpc_server_shutdown_and_notify_import; |
| 237 | #define grpc_server_shutdown_and_notify grpc_server_shutdown_and_notify_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 238 | typedef void(*grpc_server_cancel_all_calls_type)(grpc_server* server); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 239 | extern grpc_server_cancel_all_calls_type grpc_server_cancel_all_calls_import; |
| 240 | #define grpc_server_cancel_all_calls grpc_server_cancel_all_calls_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 241 | typedef void(*grpc_server_destroy_type)(grpc_server* server); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 242 | extern grpc_server_destroy_type grpc_server_destroy_import; |
| 243 | #define grpc_server_destroy grpc_server_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 244 | typedef int(*grpc_tracer_set_enabled_type)(const char* name, int enabled); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 245 | extern grpc_tracer_set_enabled_type grpc_tracer_set_enabled_import; |
| 246 | #define grpc_tracer_set_enabled grpc_tracer_set_enabled_import |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 247 | typedef int(*grpc_header_key_is_legal_type)(grpc_slice slice); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 248 | extern grpc_header_key_is_legal_type grpc_header_key_is_legal_import; |
| 249 | #define grpc_header_key_is_legal grpc_header_key_is_legal_import |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 250 | typedef int(*grpc_header_nonbin_value_is_legal_type)(grpc_slice slice); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 251 | extern grpc_header_nonbin_value_is_legal_type grpc_header_nonbin_value_is_legal_import; |
| 252 | #define grpc_header_nonbin_value_is_legal grpc_header_nonbin_value_is_legal_import |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 253 | typedef int(*grpc_is_binary_header_type)(grpc_slice slice); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 254 | extern grpc_is_binary_header_type grpc_is_binary_header_import; |
| 255 | #define grpc_is_binary_header grpc_is_binary_header_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 256 | typedef const char*(*grpc_call_error_to_string_type)(grpc_call_error error); |
Yuchen Zeng | 2e7d957 | 2016-04-15 17:29:57 -0700 | [diff] [blame] | 257 | extern grpc_call_error_to_string_type grpc_call_error_to_string_import; |
| 258 | #define grpc_call_error_to_string grpc_call_error_to_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 259 | typedef grpc_resource_quota*(*grpc_resource_quota_create_type)(const char* trace_name); |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 260 | extern grpc_resource_quota_create_type grpc_resource_quota_create_import; |
| 261 | #define grpc_resource_quota_create grpc_resource_quota_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 262 | typedef void(*grpc_resource_quota_ref_type)(grpc_resource_quota* resource_quota); |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 263 | extern grpc_resource_quota_ref_type grpc_resource_quota_ref_import; |
| 264 | #define grpc_resource_quota_ref grpc_resource_quota_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 265 | typedef void(*grpc_resource_quota_unref_type)(grpc_resource_quota* resource_quota); |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 266 | extern grpc_resource_quota_unref_type grpc_resource_quota_unref_import; |
| 267 | #define grpc_resource_quota_unref grpc_resource_quota_unref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 268 | typedef void(*grpc_resource_quota_resize_type)(grpc_resource_quota* resource_quota, size_t new_size); |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 269 | extern grpc_resource_quota_resize_type grpc_resource_quota_resize_import; |
| 270 | #define grpc_resource_quota_resize grpc_resource_quota_resize_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 271 | typedef const grpc_arg_pointer_vtable*(*grpc_resource_quota_arg_vtable_type)(void); |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 272 | extern grpc_resource_quota_arg_vtable_type grpc_resource_quota_arg_vtable_import; |
| 273 | #define grpc_resource_quota_arg_vtable grpc_resource_quota_arg_vtable_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 274 | typedef grpc_channel*(*grpc_insecure_channel_create_from_fd_type)(const char* target, int fd, const grpc_channel_args* args); |
Adam Michalik | 321b1fb | 2016-05-16 15:42:36 -0700 | [diff] [blame] | 275 | extern grpc_insecure_channel_create_from_fd_type grpc_insecure_channel_create_from_fd_import; |
| 276 | #define grpc_insecure_channel_create_from_fd grpc_insecure_channel_create_from_fd_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 277 | typedef void(*grpc_server_add_insecure_channel_from_fd_type)(grpc_server* server, void* reserved, int fd); |
Adam Michalik | bf10c82 | 2016-05-20 16:13:32 -0700 | [diff] [blame] | 278 | extern grpc_server_add_insecure_channel_from_fd_type grpc_server_add_insecure_channel_from_fd_import; |
| 279 | #define grpc_server_add_insecure_channel_from_fd grpc_server_add_insecure_channel_from_fd_import |
Sree Kuchibhotla | 492fd96 | 2016-06-10 09:03:34 -0700 | [diff] [blame] | 280 | typedef void(*grpc_use_signal_type)(int signum); |
| 281 | extern grpc_use_signal_type grpc_use_signal_import; |
| 282 | #define grpc_use_signal grpc_use_signal_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 283 | typedef const grpc_auth_property*(*grpc_auth_property_iterator_next_type)(grpc_auth_property_iterator* it); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 284 | extern grpc_auth_property_iterator_next_type grpc_auth_property_iterator_next_import; |
| 285 | #define grpc_auth_property_iterator_next grpc_auth_property_iterator_next_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 286 | typedef grpc_auth_property_iterator(*grpc_auth_context_property_iterator_type)(const grpc_auth_context* ctx); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 287 | extern grpc_auth_context_property_iterator_type grpc_auth_context_property_iterator_import; |
| 288 | #define grpc_auth_context_property_iterator grpc_auth_context_property_iterator_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 289 | typedef grpc_auth_property_iterator(*grpc_auth_context_peer_identity_type)(const grpc_auth_context* ctx); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 290 | extern grpc_auth_context_peer_identity_type grpc_auth_context_peer_identity_import; |
| 291 | #define grpc_auth_context_peer_identity grpc_auth_context_peer_identity_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 292 | typedef grpc_auth_property_iterator(*grpc_auth_context_find_properties_by_name_type)(const grpc_auth_context* ctx, const char* name); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 293 | extern grpc_auth_context_find_properties_by_name_type grpc_auth_context_find_properties_by_name_import; |
| 294 | #define grpc_auth_context_find_properties_by_name grpc_auth_context_find_properties_by_name_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 295 | typedef const char*(*grpc_auth_context_peer_identity_property_name_type)(const grpc_auth_context* ctx); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 296 | extern grpc_auth_context_peer_identity_property_name_type grpc_auth_context_peer_identity_property_name_import; |
| 297 | #define grpc_auth_context_peer_identity_property_name grpc_auth_context_peer_identity_property_name_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 298 | typedef int(*grpc_auth_context_peer_is_authenticated_type)(const grpc_auth_context* ctx); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 299 | extern grpc_auth_context_peer_is_authenticated_type grpc_auth_context_peer_is_authenticated_import; |
| 300 | #define grpc_auth_context_peer_is_authenticated grpc_auth_context_peer_is_authenticated_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 301 | typedef grpc_auth_context*(*grpc_call_auth_context_type)(grpc_call* call); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 302 | extern grpc_call_auth_context_type grpc_call_auth_context_import; |
| 303 | #define grpc_call_auth_context grpc_call_auth_context_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 304 | typedef void(*grpc_auth_context_release_type)(grpc_auth_context* context); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 305 | extern grpc_auth_context_release_type grpc_auth_context_release_import; |
| 306 | #define grpc_auth_context_release grpc_auth_context_release_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 307 | typedef void(*grpc_auth_context_add_property_type)(grpc_auth_context* ctx, const char* name, const char* value, size_t value_length); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 308 | extern grpc_auth_context_add_property_type grpc_auth_context_add_property_import; |
| 309 | #define grpc_auth_context_add_property grpc_auth_context_add_property_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 310 | typedef void(*grpc_auth_context_add_cstring_property_type)(grpc_auth_context* ctx, const char* name, const char* value); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 311 | extern grpc_auth_context_add_cstring_property_type grpc_auth_context_add_cstring_property_import; |
| 312 | #define grpc_auth_context_add_cstring_property grpc_auth_context_add_cstring_property_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 313 | typedef int(*grpc_auth_context_set_peer_identity_property_name_type)(grpc_auth_context* ctx, const char* name); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 314 | extern grpc_auth_context_set_peer_identity_property_name_type grpc_auth_context_set_peer_identity_property_name_import; |
| 315 | #define grpc_auth_context_set_peer_identity_property_name grpc_auth_context_set_peer_identity_property_name_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 316 | typedef void(*grpc_channel_credentials_release_type)(grpc_channel_credentials* creds); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 317 | extern grpc_channel_credentials_release_type grpc_channel_credentials_release_import; |
| 318 | #define grpc_channel_credentials_release grpc_channel_credentials_release_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 319 | typedef grpc_channel_credentials*(*grpc_google_default_credentials_create_type)(void); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 320 | extern grpc_google_default_credentials_create_type grpc_google_default_credentials_create_import; |
| 321 | #define grpc_google_default_credentials_create grpc_google_default_credentials_create_import |
Nicolas "Pixel" Noble | 6397660 | 2016-02-17 23:43:55 +0100 | [diff] [blame] | 322 | typedef void(*grpc_set_ssl_roots_override_callback_type)(grpc_ssl_roots_override_callback cb); |
| 323 | extern grpc_set_ssl_roots_override_callback_type grpc_set_ssl_roots_override_callback_import; |
| 324 | #define grpc_set_ssl_roots_override_callback grpc_set_ssl_roots_override_callback_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 325 | typedef grpc_channel_credentials*(*grpc_ssl_credentials_create_type)(const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 326 | extern grpc_ssl_credentials_create_type grpc_ssl_credentials_create_import; |
| 327 | #define grpc_ssl_credentials_create grpc_ssl_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 328 | typedef void(*grpc_call_credentials_release_type)(grpc_call_credentials* creds); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 329 | extern grpc_call_credentials_release_type grpc_call_credentials_release_import; |
| 330 | #define grpc_call_credentials_release grpc_call_credentials_release_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 331 | typedef grpc_channel_credentials*(*grpc_composite_channel_credentials_create_type)(grpc_channel_credentials* channel_creds, grpc_call_credentials* call_creds, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 332 | extern grpc_composite_channel_credentials_create_type grpc_composite_channel_credentials_create_import; |
| 333 | #define grpc_composite_channel_credentials_create grpc_composite_channel_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 334 | typedef grpc_call_credentials*(*grpc_composite_call_credentials_create_type)(grpc_call_credentials* creds1, grpc_call_credentials* creds2, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 335 | extern grpc_composite_call_credentials_create_type grpc_composite_call_credentials_create_import; |
| 336 | #define grpc_composite_call_credentials_create grpc_composite_call_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 337 | typedef grpc_call_credentials*(*grpc_google_compute_engine_credentials_create_type)(void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 338 | extern grpc_google_compute_engine_credentials_create_type grpc_google_compute_engine_credentials_create_import; |
| 339 | #define grpc_google_compute_engine_credentials_create grpc_google_compute_engine_credentials_create_import |
Nicolas "Pixel" Noble | d2f20ef | 2016-01-31 07:52:59 +0100 | [diff] [blame] | 340 | typedef gpr_timespec(*grpc_max_auth_token_lifetime_type)(); |
| 341 | extern grpc_max_auth_token_lifetime_type grpc_max_auth_token_lifetime_import; |
| 342 | #define grpc_max_auth_token_lifetime grpc_max_auth_token_lifetime_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 343 | typedef grpc_call_credentials*(*grpc_service_account_jwt_access_credentials_create_type)(const char* json_key, gpr_timespec token_lifetime, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 344 | extern grpc_service_account_jwt_access_credentials_create_type grpc_service_account_jwt_access_credentials_create_import; |
| 345 | #define grpc_service_account_jwt_access_credentials_create grpc_service_account_jwt_access_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 346 | typedef grpc_call_credentials*(*grpc_google_refresh_token_credentials_create_type)(const char* json_refresh_token, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 347 | extern grpc_google_refresh_token_credentials_create_type grpc_google_refresh_token_credentials_create_import; |
| 348 | #define grpc_google_refresh_token_credentials_create grpc_google_refresh_token_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 349 | typedef grpc_call_credentials*(*grpc_access_token_credentials_create_type)(const char* access_token, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 350 | extern grpc_access_token_credentials_create_type grpc_access_token_credentials_create_import; |
| 351 | #define grpc_access_token_credentials_create grpc_access_token_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 352 | typedef grpc_call_credentials*(*grpc_google_iam_credentials_create_type)(const char* authorization_token, const char* authority_selector, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 353 | extern grpc_google_iam_credentials_create_type grpc_google_iam_credentials_create_import; |
| 354 | #define grpc_google_iam_credentials_create grpc_google_iam_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 355 | typedef grpc_call_credentials*(*grpc_metadata_credentials_create_from_plugin_type)(grpc_metadata_credentials_plugin plugin, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 356 | extern grpc_metadata_credentials_create_from_plugin_type grpc_metadata_credentials_create_from_plugin_import; |
| 357 | #define grpc_metadata_credentials_create_from_plugin grpc_metadata_credentials_create_from_plugin_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 358 | typedef grpc_channel*(*grpc_secure_channel_create_type)(grpc_channel_credentials* creds, const char* target, const grpc_channel_args* args, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 359 | extern grpc_secure_channel_create_type grpc_secure_channel_create_import; |
| 360 | #define grpc_secure_channel_create grpc_secure_channel_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 361 | typedef void(*grpc_server_credentials_release_type)(grpc_server_credentials* creds); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 362 | extern grpc_server_credentials_release_type grpc_server_credentials_release_import; |
| 363 | #define grpc_server_credentials_release grpc_server_credentials_release_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 364 | typedef grpc_ssl_server_certificate_config*(*grpc_ssl_server_certificate_config_create_type)(const char* pem_root_certs, const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs); |
Justin Burke | c1d354d | 2017-09-19 15:06:01 -0700 | [diff] [blame] | 365 | extern grpc_ssl_server_certificate_config_create_type grpc_ssl_server_certificate_config_create_import; |
| 366 | #define grpc_ssl_server_certificate_config_create grpc_ssl_server_certificate_config_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 367 | typedef void(*grpc_ssl_server_certificate_config_destroy_type)(grpc_ssl_server_certificate_config* config); |
Justin Burke | c1d354d | 2017-09-19 15:06:01 -0700 | [diff] [blame] | 368 | extern grpc_ssl_server_certificate_config_destroy_type grpc_ssl_server_certificate_config_destroy_import; |
| 369 | #define grpc_ssl_server_certificate_config_destroy grpc_ssl_server_certificate_config_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 370 | typedef grpc_server_credentials*(*grpc_ssl_server_credentials_create_type)(const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs, int force_client_auth, void* reserved); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 371 | extern grpc_ssl_server_credentials_create_type grpc_ssl_server_credentials_create_import; |
| 372 | #define grpc_ssl_server_credentials_create grpc_ssl_server_credentials_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 373 | typedef grpc_server_credentials*(*grpc_ssl_server_credentials_create_ex_type)(const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs, grpc_ssl_client_certificate_request_type client_certificate_request, void* reserved); |
Deepak Lukose | dba4c5f | 2016-03-25 12:54:25 -0700 | [diff] [blame] | 374 | extern grpc_ssl_server_credentials_create_ex_type grpc_ssl_server_credentials_create_ex_import; |
| 375 | #define grpc_ssl_server_credentials_create_ex grpc_ssl_server_credentials_create_ex_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 376 | typedef grpc_ssl_server_credentials_options*(*grpc_ssl_server_credentials_create_options_using_config_type)(grpc_ssl_client_certificate_request_type client_certificate_request, grpc_ssl_server_certificate_config* certificate_config); |
Justin Burke | c1d354d | 2017-09-19 15:06:01 -0700 | [diff] [blame] | 377 | extern grpc_ssl_server_credentials_create_options_using_config_type grpc_ssl_server_credentials_create_options_using_config_import; |
| 378 | #define grpc_ssl_server_credentials_create_options_using_config grpc_ssl_server_credentials_create_options_using_config_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 379 | typedef grpc_ssl_server_credentials_options*(*grpc_ssl_server_credentials_create_options_using_config_fetcher_type)(grpc_ssl_client_certificate_request_type client_certificate_request, grpc_ssl_server_certificate_config_callback cb, void* user_data); |
Justin Burke | c1d354d | 2017-09-19 15:06:01 -0700 | [diff] [blame] | 380 | extern grpc_ssl_server_credentials_create_options_using_config_fetcher_type grpc_ssl_server_credentials_create_options_using_config_fetcher_import; |
| 381 | #define grpc_ssl_server_credentials_create_options_using_config_fetcher grpc_ssl_server_credentials_create_options_using_config_fetcher_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 382 | typedef void(*grpc_ssl_server_credentials_options_destroy_type)(grpc_ssl_server_credentials_options* options); |
Justin Burke | c1d354d | 2017-09-19 15:06:01 -0700 | [diff] [blame] | 383 | extern grpc_ssl_server_credentials_options_destroy_type grpc_ssl_server_credentials_options_destroy_import; |
| 384 | #define grpc_ssl_server_credentials_options_destroy grpc_ssl_server_credentials_options_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 385 | typedef grpc_server_credentials*(*grpc_ssl_server_credentials_create_with_options_type)(grpc_ssl_server_credentials_options* options); |
Justin Burke | c1d354d | 2017-09-19 15:06:01 -0700 | [diff] [blame] | 386 | extern grpc_ssl_server_credentials_create_with_options_type grpc_ssl_server_credentials_create_with_options_import; |
| 387 | #define grpc_ssl_server_credentials_create_with_options grpc_ssl_server_credentials_create_with_options_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 388 | typedef int(*grpc_server_add_secure_http2_port_type)(grpc_server* server, const char* addr, grpc_server_credentials* creds); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 389 | extern grpc_server_add_secure_http2_port_type grpc_server_add_secure_http2_port_import; |
| 390 | #define grpc_server_add_secure_http2_port grpc_server_add_secure_http2_port_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 391 | typedef grpc_call_error(*grpc_call_set_credentials_type)(grpc_call* call, grpc_call_credentials* creds); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 392 | extern grpc_call_set_credentials_type grpc_call_set_credentials_import; |
| 393 | #define grpc_call_set_credentials grpc_call_set_credentials_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 394 | typedef void(*grpc_server_credentials_set_auth_metadata_processor_type)(grpc_server_credentials* creds, grpc_auth_metadata_processor processor); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 395 | extern grpc_server_credentials_set_auth_metadata_processor_type grpc_server_credentials_set_auth_metadata_processor_import; |
| 396 | #define grpc_server_credentials_set_auth_metadata_processor grpc_server_credentials_set_auth_metadata_processor_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 397 | typedef grpc_byte_buffer*(*grpc_raw_byte_buffer_create_type)(grpc_slice* slices, size_t nslices); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 398 | extern grpc_raw_byte_buffer_create_type grpc_raw_byte_buffer_create_import; |
| 399 | #define grpc_raw_byte_buffer_create grpc_raw_byte_buffer_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 400 | typedef grpc_byte_buffer*(*grpc_raw_compressed_byte_buffer_create_type)(grpc_slice* slices, size_t nslices, grpc_compression_algorithm compression); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 401 | extern grpc_raw_compressed_byte_buffer_create_type grpc_raw_compressed_byte_buffer_create_import; |
| 402 | #define grpc_raw_compressed_byte_buffer_create grpc_raw_compressed_byte_buffer_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 403 | typedef grpc_byte_buffer*(*grpc_byte_buffer_copy_type)(grpc_byte_buffer* bb); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 404 | extern grpc_byte_buffer_copy_type grpc_byte_buffer_copy_import; |
| 405 | #define grpc_byte_buffer_copy grpc_byte_buffer_copy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 406 | typedef size_t(*grpc_byte_buffer_length_type)(grpc_byte_buffer* bb); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 407 | extern grpc_byte_buffer_length_type grpc_byte_buffer_length_import; |
| 408 | #define grpc_byte_buffer_length grpc_byte_buffer_length_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 409 | typedef void(*grpc_byte_buffer_destroy_type)(grpc_byte_buffer* byte_buffer); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 410 | extern grpc_byte_buffer_destroy_type grpc_byte_buffer_destroy_import; |
| 411 | #define grpc_byte_buffer_destroy grpc_byte_buffer_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 412 | typedef int(*grpc_byte_buffer_reader_init_type)(grpc_byte_buffer_reader* reader, grpc_byte_buffer* buffer); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 413 | extern grpc_byte_buffer_reader_init_type grpc_byte_buffer_reader_init_import; |
| 414 | #define grpc_byte_buffer_reader_init grpc_byte_buffer_reader_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 415 | typedef void(*grpc_byte_buffer_reader_destroy_type)(grpc_byte_buffer_reader* reader); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 416 | extern grpc_byte_buffer_reader_destroy_type grpc_byte_buffer_reader_destroy_import; |
| 417 | #define grpc_byte_buffer_reader_destroy grpc_byte_buffer_reader_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 418 | typedef int(*grpc_byte_buffer_reader_next_type)(grpc_byte_buffer_reader* reader, grpc_slice* slice); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 419 | extern grpc_byte_buffer_reader_next_type grpc_byte_buffer_reader_next_import; |
| 420 | #define grpc_byte_buffer_reader_next grpc_byte_buffer_reader_next_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 421 | typedef grpc_slice(*grpc_byte_buffer_reader_readall_type)(grpc_byte_buffer_reader* reader); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 422 | extern grpc_byte_buffer_reader_readall_type grpc_byte_buffer_reader_readall_import; |
| 423 | #define grpc_byte_buffer_reader_readall grpc_byte_buffer_reader_readall_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 424 | typedef grpc_byte_buffer*(*grpc_raw_byte_buffer_from_reader_type)(grpc_byte_buffer_reader* reader); |
Vijay Pai | efce6e1 | 2017-09-14 09:07:50 -0700 | [diff] [blame] | 425 | extern grpc_raw_byte_buffer_from_reader_type grpc_raw_byte_buffer_from_reader_import; |
| 426 | #define grpc_raw_byte_buffer_from_reader grpc_raw_byte_buffer_from_reader_import |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 427 | typedef grpc_slice(*grpc_slice_ref_type)(grpc_slice s); |
| 428 | extern grpc_slice_ref_type grpc_slice_ref_import; |
| 429 | #define grpc_slice_ref grpc_slice_ref_import |
| 430 | typedef void(*grpc_slice_unref_type)(grpc_slice s); |
| 431 | extern grpc_slice_unref_type grpc_slice_unref_import; |
| 432 | #define grpc_slice_unref grpc_slice_unref_import |
Craig Tiller | bb4046c | 2017-04-26 08:56:30 -0700 | [diff] [blame] | 433 | typedef grpc_slice(*grpc_slice_copy_type)(grpc_slice s); |
| 434 | extern grpc_slice_copy_type grpc_slice_copy_import; |
| 435 | #define grpc_slice_copy grpc_slice_copy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 436 | typedef grpc_slice(*grpc_slice_new_type)(void* p, size_t len, void (*destroy)(void*)); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 437 | extern grpc_slice_new_type grpc_slice_new_import; |
| 438 | #define grpc_slice_new grpc_slice_new_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 439 | typedef grpc_slice(*grpc_slice_new_with_user_data_type)(void* p, size_t len, void (*destroy)(void*), void* user_data); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 440 | extern grpc_slice_new_with_user_data_type grpc_slice_new_with_user_data_import; |
| 441 | #define grpc_slice_new_with_user_data grpc_slice_new_with_user_data_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 442 | typedef grpc_slice(*grpc_slice_new_with_len_type)(void* p, size_t len, void (*destroy)(void*, size_t)); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 443 | extern grpc_slice_new_with_len_type grpc_slice_new_with_len_import; |
| 444 | #define grpc_slice_new_with_len grpc_slice_new_with_len_import |
| 445 | typedef grpc_slice(*grpc_slice_malloc_type)(size_t length); |
| 446 | extern grpc_slice_malloc_type grpc_slice_malloc_import; |
| 447 | #define grpc_slice_malloc grpc_slice_malloc_import |
Craig Tiller | c39fbcf | 2017-04-17 08:20:25 -0700 | [diff] [blame] | 448 | typedef grpc_slice(*grpc_slice_malloc_large_type)(size_t length); |
| 449 | extern grpc_slice_malloc_large_type grpc_slice_malloc_large_import; |
| 450 | #define grpc_slice_malloc_large grpc_slice_malloc_large_import |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 451 | typedef grpc_slice(*grpc_slice_intern_type)(grpc_slice slice); |
| 452 | extern grpc_slice_intern_type grpc_slice_intern_import; |
| 453 | #define grpc_slice_intern grpc_slice_intern_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 454 | typedef grpc_slice(*grpc_slice_from_copied_string_type)(const char* source); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 455 | extern grpc_slice_from_copied_string_type grpc_slice_from_copied_string_import; |
| 456 | #define grpc_slice_from_copied_string grpc_slice_from_copied_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 457 | typedef grpc_slice(*grpc_slice_from_copied_buffer_type)(const char* source, size_t len); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 458 | extern grpc_slice_from_copied_buffer_type grpc_slice_from_copied_buffer_import; |
| 459 | #define grpc_slice_from_copied_buffer grpc_slice_from_copied_buffer_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 460 | typedef grpc_slice(*grpc_slice_from_static_string_type)(const char* source); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 461 | extern grpc_slice_from_static_string_type grpc_slice_from_static_string_import; |
| 462 | #define grpc_slice_from_static_string grpc_slice_from_static_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 463 | typedef grpc_slice(*grpc_slice_from_static_buffer_type)(const void* source, size_t len); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 464 | extern grpc_slice_from_static_buffer_type grpc_slice_from_static_buffer_import; |
| 465 | #define grpc_slice_from_static_buffer grpc_slice_from_static_buffer_import |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 466 | typedef grpc_slice(*grpc_slice_sub_type)(grpc_slice s, size_t begin, size_t end); |
| 467 | extern grpc_slice_sub_type grpc_slice_sub_import; |
| 468 | #define grpc_slice_sub grpc_slice_sub_import |
| 469 | typedef grpc_slice(*grpc_slice_sub_no_ref_type)(grpc_slice s, size_t begin, size_t end); |
| 470 | extern grpc_slice_sub_no_ref_type grpc_slice_sub_no_ref_import; |
| 471 | #define grpc_slice_sub_no_ref grpc_slice_sub_no_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 472 | typedef grpc_slice(*grpc_slice_split_tail_type)(grpc_slice* s, size_t split); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 473 | extern grpc_slice_split_tail_type grpc_slice_split_tail_import; |
| 474 | #define grpc_slice_split_tail grpc_slice_split_tail_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 475 | typedef grpc_slice(*grpc_slice_split_tail_maybe_ref_type)(grpc_slice* s, size_t split, grpc_slice_ref_whom ref_whom); |
Craig Tiller | c39fbcf | 2017-04-17 08:20:25 -0700 | [diff] [blame] | 476 | extern grpc_slice_split_tail_maybe_ref_type grpc_slice_split_tail_maybe_ref_import; |
| 477 | #define grpc_slice_split_tail_maybe_ref grpc_slice_split_tail_maybe_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 478 | typedef grpc_slice(*grpc_slice_split_head_type)(grpc_slice* s, size_t split); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 479 | extern grpc_slice_split_head_type grpc_slice_split_head_import; |
| 480 | #define grpc_slice_split_head grpc_slice_split_head_import |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 481 | typedef grpc_slice(*grpc_empty_slice_type)(void); |
| 482 | extern grpc_empty_slice_type grpc_empty_slice_import; |
| 483 | #define grpc_empty_slice grpc_empty_slice_import |
| 484 | typedef uint32_t(*grpc_slice_default_hash_impl_type)(grpc_slice s); |
| 485 | extern grpc_slice_default_hash_impl_type grpc_slice_default_hash_impl_import; |
| 486 | #define grpc_slice_default_hash_impl grpc_slice_default_hash_impl_import |
| 487 | typedef int(*grpc_slice_default_eq_impl_type)(grpc_slice a, grpc_slice b); |
| 488 | extern grpc_slice_default_eq_impl_type grpc_slice_default_eq_impl_import; |
| 489 | #define grpc_slice_default_eq_impl grpc_slice_default_eq_impl_import |
| 490 | typedef int(*grpc_slice_eq_type)(grpc_slice a, grpc_slice b); |
| 491 | extern grpc_slice_eq_type grpc_slice_eq_import; |
| 492 | #define grpc_slice_eq grpc_slice_eq_import |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 493 | typedef int(*grpc_slice_cmp_type)(grpc_slice a, grpc_slice b); |
| 494 | extern grpc_slice_cmp_type grpc_slice_cmp_import; |
| 495 | #define grpc_slice_cmp grpc_slice_cmp_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 496 | typedef int(*grpc_slice_str_cmp_type)(grpc_slice a, const char* b); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 497 | extern grpc_slice_str_cmp_type grpc_slice_str_cmp_import; |
| 498 | #define grpc_slice_str_cmp grpc_slice_str_cmp_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 499 | typedef int(*grpc_slice_buf_start_eq_type)(grpc_slice a, const void* b, size_t blen); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 500 | extern grpc_slice_buf_start_eq_type grpc_slice_buf_start_eq_import; |
| 501 | #define grpc_slice_buf_start_eq grpc_slice_buf_start_eq_import |
| 502 | typedef int(*grpc_slice_rchr_type)(grpc_slice s, char c); |
| 503 | extern grpc_slice_rchr_type grpc_slice_rchr_import; |
| 504 | #define grpc_slice_rchr grpc_slice_rchr_import |
| 505 | typedef int(*grpc_slice_chr_type)(grpc_slice s, char c); |
| 506 | extern grpc_slice_chr_type grpc_slice_chr_import; |
| 507 | #define grpc_slice_chr grpc_slice_chr_import |
| 508 | typedef int(*grpc_slice_slice_type)(grpc_slice haystack, grpc_slice needle); |
| 509 | extern grpc_slice_slice_type grpc_slice_slice_import; |
| 510 | #define grpc_slice_slice grpc_slice_slice_import |
| 511 | typedef uint32_t(*grpc_slice_hash_type)(grpc_slice s); |
| 512 | extern grpc_slice_hash_type grpc_slice_hash_import; |
| 513 | #define grpc_slice_hash grpc_slice_hash_import |
Craig Tiller | c586666 | 2016-11-16 15:25:00 -0800 | [diff] [blame] | 514 | typedef int(*grpc_slice_is_equivalent_type)(grpc_slice a, grpc_slice b); |
| 515 | extern grpc_slice_is_equivalent_type grpc_slice_is_equivalent_import; |
| 516 | #define grpc_slice_is_equivalent grpc_slice_is_equivalent_import |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 517 | typedef grpc_slice(*grpc_slice_dup_type)(grpc_slice a); |
| 518 | extern grpc_slice_dup_type grpc_slice_dup_import; |
| 519 | #define grpc_slice_dup grpc_slice_dup_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 520 | typedef char*(*grpc_slice_to_c_string_type)(grpc_slice s); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 521 | extern grpc_slice_to_c_string_type grpc_slice_to_c_string_import; |
| 522 | #define grpc_slice_to_c_string grpc_slice_to_c_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 523 | typedef void(*grpc_slice_buffer_init_type)(grpc_slice_buffer* sb); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 524 | extern grpc_slice_buffer_init_type grpc_slice_buffer_init_import; |
| 525 | #define grpc_slice_buffer_init grpc_slice_buffer_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 526 | typedef void(*grpc_slice_buffer_destroy_type)(grpc_slice_buffer* sb); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 527 | extern grpc_slice_buffer_destroy_type grpc_slice_buffer_destroy_import; |
| 528 | #define grpc_slice_buffer_destroy grpc_slice_buffer_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 529 | typedef void(*grpc_slice_buffer_add_type)(grpc_slice_buffer* sb, grpc_slice slice); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 530 | extern grpc_slice_buffer_add_type grpc_slice_buffer_add_import; |
| 531 | #define grpc_slice_buffer_add grpc_slice_buffer_add_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 532 | typedef size_t(*grpc_slice_buffer_add_indexed_type)(grpc_slice_buffer* sb, grpc_slice slice); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 533 | extern grpc_slice_buffer_add_indexed_type grpc_slice_buffer_add_indexed_import; |
| 534 | #define grpc_slice_buffer_add_indexed grpc_slice_buffer_add_indexed_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 535 | typedef void(*grpc_slice_buffer_addn_type)(grpc_slice_buffer* sb, grpc_slice* slices, size_t n); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 536 | extern grpc_slice_buffer_addn_type grpc_slice_buffer_addn_import; |
| 537 | #define grpc_slice_buffer_addn grpc_slice_buffer_addn_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 538 | typedef uint8_t*(*grpc_slice_buffer_tiny_add_type)(grpc_slice_buffer* sb, size_t len); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 539 | extern grpc_slice_buffer_tiny_add_type grpc_slice_buffer_tiny_add_import; |
| 540 | #define grpc_slice_buffer_tiny_add grpc_slice_buffer_tiny_add_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 541 | typedef void(*grpc_slice_buffer_pop_type)(grpc_slice_buffer* sb); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 542 | extern grpc_slice_buffer_pop_type grpc_slice_buffer_pop_import; |
| 543 | #define grpc_slice_buffer_pop grpc_slice_buffer_pop_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 544 | typedef void(*grpc_slice_buffer_reset_and_unref_type)(grpc_slice_buffer* sb); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 545 | extern grpc_slice_buffer_reset_and_unref_type grpc_slice_buffer_reset_and_unref_import; |
| 546 | #define grpc_slice_buffer_reset_and_unref grpc_slice_buffer_reset_and_unref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 547 | typedef void(*grpc_slice_buffer_swap_type)(grpc_slice_buffer* a, grpc_slice_buffer* b); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 548 | extern grpc_slice_buffer_swap_type grpc_slice_buffer_swap_import; |
| 549 | #define grpc_slice_buffer_swap grpc_slice_buffer_swap_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 550 | typedef void(*grpc_slice_buffer_move_into_type)(grpc_slice_buffer* src, grpc_slice_buffer* dst); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 551 | extern grpc_slice_buffer_move_into_type grpc_slice_buffer_move_into_import; |
| 552 | #define grpc_slice_buffer_move_into grpc_slice_buffer_move_into_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 553 | typedef void(*grpc_slice_buffer_trim_end_type)(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* garbage); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 554 | extern grpc_slice_buffer_trim_end_type grpc_slice_buffer_trim_end_import; |
| 555 | #define grpc_slice_buffer_trim_end grpc_slice_buffer_trim_end_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 556 | typedef void(*grpc_slice_buffer_move_first_type)(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* dst); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 557 | extern grpc_slice_buffer_move_first_type grpc_slice_buffer_move_first_import; |
| 558 | #define grpc_slice_buffer_move_first grpc_slice_buffer_move_first_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 559 | typedef void(*grpc_slice_buffer_move_first_no_ref_type)(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* dst); |
Craig Tiller | c39fbcf | 2017-04-17 08:20:25 -0700 | [diff] [blame] | 560 | extern grpc_slice_buffer_move_first_no_ref_type grpc_slice_buffer_move_first_no_ref_import; |
| 561 | #define grpc_slice_buffer_move_first_no_ref grpc_slice_buffer_move_first_no_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 562 | typedef void(*grpc_slice_buffer_move_first_into_buffer_type)(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* src, size_t n, void* dst); |
Craig Tiller | 0cf6a71 | 2017-01-20 14:07:05 -0800 | [diff] [blame] | 563 | extern grpc_slice_buffer_move_first_into_buffer_type grpc_slice_buffer_move_first_into_buffer_import; |
| 564 | #define grpc_slice_buffer_move_first_into_buffer grpc_slice_buffer_move_first_into_buffer_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 565 | typedef grpc_slice(*grpc_slice_buffer_take_first_type)(grpc_slice_buffer* src); |
Craig Tiller | c335054 | 2016-10-26 16:19:01 -0700 | [diff] [blame] | 566 | extern grpc_slice_buffer_take_first_type grpc_slice_buffer_take_first_import; |
| 567 | #define grpc_slice_buffer_take_first grpc_slice_buffer_take_first_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 568 | typedef void(*grpc_slice_buffer_undo_take_first_type)(grpc_slice_buffer* src, grpc_slice slice); |
Craig Tiller | 0cf6a71 | 2017-01-20 14:07:05 -0800 | [diff] [blame] | 569 | extern grpc_slice_buffer_undo_take_first_type grpc_slice_buffer_undo_take_first_import; |
| 570 | #define grpc_slice_buffer_undo_take_first grpc_slice_buffer_undo_take_first_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 571 | typedef void*(*gpr_malloc_type)(size_t size); |
David Garcia Quintas | 3b31fdf | 2016-07-27 18:17:12 -0700 | [diff] [blame] | 572 | extern gpr_malloc_type gpr_malloc_import; |
| 573 | #define gpr_malloc gpr_malloc_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 574 | typedef void*(*gpr_zalloc_type)(size_t size); |
Craig Tiller | ff71449 | 2017-02-17 09:02:18 -0800 | [diff] [blame] | 575 | extern gpr_zalloc_type gpr_zalloc_import; |
| 576 | #define gpr_zalloc gpr_zalloc_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 577 | typedef void(*gpr_free_type)(void* ptr); |
David Garcia Quintas | 3b31fdf | 2016-07-27 18:17:12 -0700 | [diff] [blame] | 578 | extern gpr_free_type gpr_free_import; |
| 579 | #define gpr_free gpr_free_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 580 | typedef void*(*gpr_realloc_type)(void* p, size_t size); |
David Garcia Quintas | 3b31fdf | 2016-07-27 18:17:12 -0700 | [diff] [blame] | 581 | extern gpr_realloc_type gpr_realloc_import; |
| 582 | #define gpr_realloc gpr_realloc_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 583 | typedef void*(*gpr_malloc_aligned_type)(size_t size, size_t alignment_log); |
David Garcia Quintas | 3b31fdf | 2016-07-27 18:17:12 -0700 | [diff] [blame] | 584 | extern gpr_malloc_aligned_type gpr_malloc_aligned_import; |
| 585 | #define gpr_malloc_aligned gpr_malloc_aligned_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 586 | typedef void(*gpr_free_aligned_type)(void* ptr); |
David Garcia Quintas | 3b31fdf | 2016-07-27 18:17:12 -0700 | [diff] [blame] | 587 | extern gpr_free_aligned_type gpr_free_aligned_import; |
| 588 | #define gpr_free_aligned gpr_free_aligned_import |
| 589 | typedef void(*gpr_set_allocation_functions_type)(gpr_allocation_functions functions); |
| 590 | extern gpr_set_allocation_functions_type gpr_set_allocation_functions_import; |
| 591 | #define gpr_set_allocation_functions gpr_set_allocation_functions_import |
| 592 | typedef gpr_allocation_functions(*gpr_get_allocation_functions_type)(); |
| 593 | extern gpr_get_allocation_functions_type gpr_get_allocation_functions_import; |
| 594 | #define gpr_get_allocation_functions gpr_get_allocation_functions_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 595 | typedef gpr_avl(*gpr_avl_create_type)(const gpr_avl_vtable* vtable); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 596 | extern gpr_avl_create_type gpr_avl_create_import; |
| 597 | #define gpr_avl_create gpr_avl_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 598 | typedef gpr_avl(*gpr_avl_ref_type)(gpr_avl avl, void* user_data); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 599 | extern gpr_avl_ref_type gpr_avl_ref_import; |
| 600 | #define gpr_avl_ref gpr_avl_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 601 | typedef void(*gpr_avl_unref_type)(gpr_avl avl, void* user_data); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 602 | extern gpr_avl_unref_type gpr_avl_unref_import; |
| 603 | #define gpr_avl_unref gpr_avl_unref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 604 | typedef gpr_avl(*gpr_avl_add_type)(gpr_avl avl, void* key, void* value, void* user_data); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 605 | extern gpr_avl_add_type gpr_avl_add_import; |
| 606 | #define gpr_avl_add gpr_avl_add_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 607 | typedef gpr_avl(*gpr_avl_remove_type)(gpr_avl avl, void* key, void* user_data); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 608 | extern gpr_avl_remove_type gpr_avl_remove_import; |
| 609 | #define gpr_avl_remove gpr_avl_remove_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 610 | typedef void*(*gpr_avl_get_type)(gpr_avl avl, void* key, void* user_data); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 611 | extern gpr_avl_get_type gpr_avl_get_import; |
| 612 | #define gpr_avl_get gpr_avl_get_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 613 | typedef int(*gpr_avl_maybe_get_type)(gpr_avl avl, void* key, void** value, void* user_data); |
Craig Tiller | d6a5b80 | 2016-05-13 20:17:38 -0700 | [diff] [blame] | 614 | extern gpr_avl_maybe_get_type gpr_avl_maybe_get_import; |
| 615 | #define gpr_avl_maybe_get gpr_avl_maybe_get_import |
| 616 | typedef int(*gpr_avl_is_empty_type)(gpr_avl avl); |
| 617 | extern gpr_avl_is_empty_type gpr_avl_is_empty_import; |
| 618 | #define gpr_avl_is_empty gpr_avl_is_empty_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 619 | typedef gpr_cmdline*(*gpr_cmdline_create_type)(const char* description); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 620 | extern gpr_cmdline_create_type gpr_cmdline_create_import; |
| 621 | #define gpr_cmdline_create gpr_cmdline_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 622 | typedef void(*gpr_cmdline_add_int_type)(gpr_cmdline* cl, const char* name, const char* help, int* value); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 623 | extern gpr_cmdline_add_int_type gpr_cmdline_add_int_import; |
| 624 | #define gpr_cmdline_add_int gpr_cmdline_add_int_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 625 | typedef void(*gpr_cmdline_add_flag_type)(gpr_cmdline* cl, const char* name, const char* help, int* value); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 626 | extern gpr_cmdline_add_flag_type gpr_cmdline_add_flag_import; |
| 627 | #define gpr_cmdline_add_flag gpr_cmdline_add_flag_import |
Yash Tibrewal | 40422d5 | 2017-11-06 14:39:17 -0800 | [diff] [blame] | 628 | typedef void(*gpr_cmdline_add_string_type)(gpr_cmdline* cl, const char* name, const char* help, const char** value); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 629 | extern gpr_cmdline_add_string_type gpr_cmdline_add_string_import; |
| 630 | #define gpr_cmdline_add_string gpr_cmdline_add_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 631 | typedef void(*gpr_cmdline_on_extra_arg_type)(gpr_cmdline* cl, const char* name, const char* help, void (*on_extra_arg)(void* user_data, const char* arg), void* user_data); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 632 | extern gpr_cmdline_on_extra_arg_type gpr_cmdline_on_extra_arg_import; |
| 633 | #define gpr_cmdline_on_extra_arg gpr_cmdline_on_extra_arg_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 634 | typedef void(*gpr_cmdline_set_survive_failure_type)(gpr_cmdline* cl); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 635 | extern gpr_cmdline_set_survive_failure_type gpr_cmdline_set_survive_failure_import; |
| 636 | #define gpr_cmdline_set_survive_failure gpr_cmdline_set_survive_failure_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 637 | typedef int(*gpr_cmdline_parse_type)(gpr_cmdline* cl, int argc, char** argv); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 638 | extern gpr_cmdline_parse_type gpr_cmdline_parse_import; |
| 639 | #define gpr_cmdline_parse gpr_cmdline_parse_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 640 | typedef void(*gpr_cmdline_destroy_type)(gpr_cmdline* cl); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 641 | extern gpr_cmdline_destroy_type gpr_cmdline_destroy_import; |
| 642 | #define gpr_cmdline_destroy gpr_cmdline_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 643 | typedef char*(*gpr_cmdline_usage_string_type)(gpr_cmdline* cl, const char* argv0); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 644 | extern gpr_cmdline_usage_string_type gpr_cmdline_usage_string_import; |
| 645 | #define gpr_cmdline_usage_string gpr_cmdline_usage_string_import |
| 646 | typedef unsigned(*gpr_cpu_num_cores_type)(void); |
| 647 | extern gpr_cpu_num_cores_type gpr_cpu_num_cores_import; |
| 648 | #define gpr_cpu_num_cores gpr_cpu_num_cores_import |
| 649 | typedef unsigned(*gpr_cpu_current_cpu_type)(void); |
| 650 | extern gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import; |
| 651 | #define gpr_cpu_current_cpu gpr_cpu_current_cpu_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 652 | typedef gpr_histogram*(*gpr_histogram_create_type)(double resolution, double max_bucket_start); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 653 | extern gpr_histogram_create_type gpr_histogram_create_import; |
| 654 | #define gpr_histogram_create gpr_histogram_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 655 | typedef void(*gpr_histogram_destroy_type)(gpr_histogram* h); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 656 | extern gpr_histogram_destroy_type gpr_histogram_destroy_import; |
| 657 | #define gpr_histogram_destroy gpr_histogram_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 658 | typedef void(*gpr_histogram_add_type)(gpr_histogram* h, double x); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 659 | extern gpr_histogram_add_type gpr_histogram_add_import; |
| 660 | #define gpr_histogram_add gpr_histogram_add_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 661 | typedef int(*gpr_histogram_merge_type)(gpr_histogram* dst, const gpr_histogram* src); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 662 | extern gpr_histogram_merge_type gpr_histogram_merge_import; |
| 663 | #define gpr_histogram_merge gpr_histogram_merge_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 664 | typedef double(*gpr_histogram_percentile_type)(gpr_histogram* histogram, double percentile); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 665 | extern gpr_histogram_percentile_type gpr_histogram_percentile_import; |
| 666 | #define gpr_histogram_percentile gpr_histogram_percentile_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 667 | typedef double(*gpr_histogram_mean_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 668 | extern gpr_histogram_mean_type gpr_histogram_mean_import; |
| 669 | #define gpr_histogram_mean gpr_histogram_mean_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 670 | typedef double(*gpr_histogram_stddev_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 671 | extern gpr_histogram_stddev_type gpr_histogram_stddev_import; |
| 672 | #define gpr_histogram_stddev gpr_histogram_stddev_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 673 | typedef double(*gpr_histogram_variance_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 674 | extern gpr_histogram_variance_type gpr_histogram_variance_import; |
| 675 | #define gpr_histogram_variance gpr_histogram_variance_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 676 | typedef double(*gpr_histogram_maximum_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 677 | extern gpr_histogram_maximum_type gpr_histogram_maximum_import; |
| 678 | #define gpr_histogram_maximum gpr_histogram_maximum_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 679 | typedef double(*gpr_histogram_minimum_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 680 | extern gpr_histogram_minimum_type gpr_histogram_minimum_import; |
| 681 | #define gpr_histogram_minimum gpr_histogram_minimum_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 682 | typedef double(*gpr_histogram_count_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 683 | extern gpr_histogram_count_type gpr_histogram_count_import; |
| 684 | #define gpr_histogram_count gpr_histogram_count_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 685 | typedef double(*gpr_histogram_sum_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 686 | extern gpr_histogram_sum_type gpr_histogram_sum_import; |
| 687 | #define gpr_histogram_sum gpr_histogram_sum_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 688 | typedef double(*gpr_histogram_sum_of_squares_type)(gpr_histogram* histogram); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 689 | extern gpr_histogram_sum_of_squares_type gpr_histogram_sum_of_squares_import; |
| 690 | #define gpr_histogram_sum_of_squares gpr_histogram_sum_of_squares_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 691 | typedef const uint32_t*(*gpr_histogram_get_contents_type)(gpr_histogram* histogram, size_t* count); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 692 | extern gpr_histogram_get_contents_type gpr_histogram_get_contents_import; |
| 693 | #define gpr_histogram_get_contents gpr_histogram_get_contents_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 694 | typedef void(*gpr_histogram_merge_contents_type)(gpr_histogram* histogram, const uint32_t* data, size_t data_count, double min_seen, double max_seen, double sum, double sum_of_squares, double count); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 695 | extern gpr_histogram_merge_contents_type gpr_histogram_merge_contents_import; |
| 696 | #define gpr_histogram_merge_contents gpr_histogram_merge_contents_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 697 | typedef int(*gpr_join_host_port_type)(char** out, const char* host, int port); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 698 | extern gpr_join_host_port_type gpr_join_host_port_import; |
| 699 | #define gpr_join_host_port gpr_join_host_port_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 700 | typedef int(*gpr_split_host_port_type)(const char* name, char** host, char** port); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 701 | extern gpr_split_host_port_type gpr_split_host_port_import; |
| 702 | #define gpr_split_host_port gpr_split_host_port_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 703 | typedef const char*(*gpr_log_severity_string_type)(gpr_log_severity severity); |
Craig Tiller | cc91983 | 2017-05-23 13:35:55 -0700 | [diff] [blame] | 704 | extern gpr_log_severity_string_type gpr_log_severity_string_import; |
| 705 | #define gpr_log_severity_string gpr_log_severity_string_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 706 | typedef void(*gpr_log_type)(const char* file, int line, gpr_log_severity severity, const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5); |
David Garcia Quintas | c79b065 | 2016-07-27 21:11:58 -0700 | [diff] [blame] | 707 | extern gpr_log_type gpr_log_import; |
| 708 | #define gpr_log gpr_log_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 709 | typedef void(*gpr_log_message_type)(const char* file, int line, gpr_log_severity severity, const char* message); |
David Garcia Quintas | c79b065 | 2016-07-27 21:11:58 -0700 | [diff] [blame] | 710 | extern gpr_log_message_type gpr_log_message_import; |
| 711 | #define gpr_log_message gpr_log_message_import |
| 712 | typedef void(*gpr_set_log_verbosity_type)(gpr_log_severity min_severity_to_print); |
| 713 | extern gpr_set_log_verbosity_type gpr_set_log_verbosity_import; |
| 714 | #define gpr_set_log_verbosity gpr_set_log_verbosity_import |
| 715 | typedef void(*gpr_log_verbosity_init_type)(); |
| 716 | extern gpr_log_verbosity_init_type gpr_log_verbosity_init_import; |
| 717 | #define gpr_log_verbosity_init gpr_log_verbosity_init_import |
| 718 | typedef void(*gpr_set_log_function_type)(gpr_log_func func); |
| 719 | extern gpr_set_log_function_type gpr_set_log_function_import; |
| 720 | #define gpr_set_log_function gpr_set_log_function_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 721 | typedef char*(*gpr_format_message_type)(int messageid); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 722 | extern gpr_format_message_type gpr_format_message_import; |
| 723 | #define gpr_format_message gpr_format_message_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 724 | typedef char*(*gpr_strdup_type)(const char* src); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 725 | extern gpr_strdup_type gpr_strdup_import; |
| 726 | #define gpr_strdup gpr_strdup_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 727 | typedef int(*gpr_asprintf_type)(char** strp, const char* format, ...) GPR_PRINT_FORMAT_CHECK(2, 3); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 728 | extern gpr_asprintf_type gpr_asprintf_import; |
| 729 | #define gpr_asprintf gpr_asprintf_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 730 | typedef const char*(*gpr_subprocess_binary_extension_type)(); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 731 | extern gpr_subprocess_binary_extension_type gpr_subprocess_binary_extension_import; |
| 732 | #define gpr_subprocess_binary_extension gpr_subprocess_binary_extension_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 733 | typedef gpr_subprocess*(*gpr_subprocess_create_type)(int argc, const char** argv); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 734 | extern gpr_subprocess_create_type gpr_subprocess_create_import; |
| 735 | #define gpr_subprocess_create gpr_subprocess_create_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 736 | typedef void(*gpr_subprocess_destroy_type)(gpr_subprocess* p); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 737 | extern gpr_subprocess_destroy_type gpr_subprocess_destroy_import; |
| 738 | #define gpr_subprocess_destroy gpr_subprocess_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 739 | typedef int(*gpr_subprocess_join_type)(gpr_subprocess* p); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 740 | extern gpr_subprocess_join_type gpr_subprocess_join_import; |
| 741 | #define gpr_subprocess_join gpr_subprocess_join_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 742 | typedef void(*gpr_subprocess_interrupt_type)(gpr_subprocess* p); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 743 | extern gpr_subprocess_interrupt_type gpr_subprocess_interrupt_import; |
| 744 | #define gpr_subprocess_interrupt gpr_subprocess_interrupt_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 745 | typedef void(*gpr_mu_init_type)(gpr_mu* mu); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 746 | extern gpr_mu_init_type gpr_mu_init_import; |
| 747 | #define gpr_mu_init gpr_mu_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 748 | typedef void(*gpr_mu_destroy_type)(gpr_mu* mu); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 749 | extern gpr_mu_destroy_type gpr_mu_destroy_import; |
| 750 | #define gpr_mu_destroy gpr_mu_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 751 | typedef void(*gpr_mu_lock_type)(gpr_mu* mu); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 752 | extern gpr_mu_lock_type gpr_mu_lock_import; |
| 753 | #define gpr_mu_lock gpr_mu_lock_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 754 | typedef void(*gpr_mu_unlock_type)(gpr_mu* mu); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 755 | extern gpr_mu_unlock_type gpr_mu_unlock_import; |
| 756 | #define gpr_mu_unlock gpr_mu_unlock_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 757 | typedef int(*gpr_mu_trylock_type)(gpr_mu* mu); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 758 | extern gpr_mu_trylock_type gpr_mu_trylock_import; |
| 759 | #define gpr_mu_trylock gpr_mu_trylock_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 760 | typedef void(*gpr_cv_init_type)(gpr_cv* cv); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 761 | extern gpr_cv_init_type gpr_cv_init_import; |
| 762 | #define gpr_cv_init gpr_cv_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 763 | typedef void(*gpr_cv_destroy_type)(gpr_cv* cv); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 764 | extern gpr_cv_destroy_type gpr_cv_destroy_import; |
| 765 | #define gpr_cv_destroy gpr_cv_destroy_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 766 | typedef int(*gpr_cv_wait_type)(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 767 | extern gpr_cv_wait_type gpr_cv_wait_import; |
| 768 | #define gpr_cv_wait gpr_cv_wait_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 769 | typedef void(*gpr_cv_signal_type)(gpr_cv* cv); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 770 | extern gpr_cv_signal_type gpr_cv_signal_import; |
| 771 | #define gpr_cv_signal gpr_cv_signal_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 772 | typedef void(*gpr_cv_broadcast_type)(gpr_cv* cv); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 773 | extern gpr_cv_broadcast_type gpr_cv_broadcast_import; |
| 774 | #define gpr_cv_broadcast gpr_cv_broadcast_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 775 | typedef void(*gpr_once_init_type)(gpr_once* once, void (*init_routine)(void)); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 776 | extern gpr_once_init_type gpr_once_init_import; |
| 777 | #define gpr_once_init gpr_once_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 778 | typedef void(*gpr_event_init_type)(gpr_event* ev); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 779 | extern gpr_event_init_type gpr_event_init_import; |
| 780 | #define gpr_event_init gpr_event_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 781 | typedef void(*gpr_event_set_type)(gpr_event* ev, void* value); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 782 | extern gpr_event_set_type gpr_event_set_import; |
| 783 | #define gpr_event_set gpr_event_set_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 784 | typedef void*(*gpr_event_get_type)(gpr_event* ev); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 785 | extern gpr_event_get_type gpr_event_get_import; |
| 786 | #define gpr_event_get gpr_event_get_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 787 | typedef void*(*gpr_event_wait_type)(gpr_event* ev, gpr_timespec abs_deadline); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 788 | extern gpr_event_wait_type gpr_event_wait_import; |
| 789 | #define gpr_event_wait gpr_event_wait_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 790 | typedef void(*gpr_ref_init_type)(gpr_refcount* r, int n); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 791 | extern gpr_ref_init_type gpr_ref_init_import; |
| 792 | #define gpr_ref_init gpr_ref_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 793 | typedef void(*gpr_ref_type)(gpr_refcount* r); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 794 | extern gpr_ref_type gpr_ref_import; |
| 795 | #define gpr_ref gpr_ref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 796 | typedef void(*gpr_ref_non_zero_type)(gpr_refcount* r); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 797 | extern gpr_ref_non_zero_type gpr_ref_non_zero_import; |
| 798 | #define gpr_ref_non_zero gpr_ref_non_zero_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 799 | typedef void(*gpr_refn_type)(gpr_refcount* r, int n); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 800 | extern gpr_refn_type gpr_refn_import; |
| 801 | #define gpr_refn gpr_refn_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 802 | typedef int(*gpr_unref_type)(gpr_refcount* r); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 803 | extern gpr_unref_type gpr_unref_import; |
| 804 | #define gpr_unref gpr_unref_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 805 | typedef int(*gpr_ref_is_unique_type)(gpr_refcount* r); |
ncteisen | 3da3ce3 | 2017-02-17 09:51:25 -0800 | [diff] [blame] | 806 | extern gpr_ref_is_unique_type gpr_ref_is_unique_import; |
| 807 | #define gpr_ref_is_unique gpr_ref_is_unique_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 808 | typedef void(*gpr_stats_init_type)(gpr_stats_counter* c, intptr_t n); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 809 | extern gpr_stats_init_type gpr_stats_init_import; |
| 810 | #define gpr_stats_init gpr_stats_init_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 811 | typedef void(*gpr_stats_inc_type)(gpr_stats_counter* c, intptr_t inc); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 812 | extern gpr_stats_inc_type gpr_stats_inc_import; |
| 813 | #define gpr_stats_inc gpr_stats_inc_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 814 | typedef intptr_t(*gpr_stats_read_type)(const gpr_stats_counter* c); |
David Garcia Quintas | 2ee99f4 | 2016-08-01 19:15:31 -0700 | [diff] [blame] | 815 | extern gpr_stats_read_type gpr_stats_read_import; |
| 816 | #define gpr_stats_read gpr_stats_read_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 817 | typedef int(*gpr_thd_new_type)(gpr_thd_id* t, void (*thd_body)(void* arg), void* arg, const gpr_thd_options* options); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 818 | extern gpr_thd_new_type gpr_thd_new_import; |
| 819 | #define gpr_thd_new gpr_thd_new_import |
| 820 | typedef gpr_thd_options(*gpr_thd_options_default_type)(void); |
| 821 | extern gpr_thd_options_default_type gpr_thd_options_default_import; |
| 822 | #define gpr_thd_options_default gpr_thd_options_default_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 823 | typedef void(*gpr_thd_options_set_detached_type)(gpr_thd_options* options); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 824 | extern gpr_thd_options_set_detached_type gpr_thd_options_set_detached_import; |
| 825 | #define gpr_thd_options_set_detached gpr_thd_options_set_detached_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 826 | typedef void(*gpr_thd_options_set_joinable_type)(gpr_thd_options* options); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 827 | extern gpr_thd_options_set_joinable_type gpr_thd_options_set_joinable_import; |
| 828 | #define gpr_thd_options_set_joinable gpr_thd_options_set_joinable_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 829 | typedef int(*gpr_thd_options_is_detached_type)(const gpr_thd_options* options); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 830 | extern gpr_thd_options_is_detached_type gpr_thd_options_is_detached_import; |
| 831 | #define gpr_thd_options_is_detached gpr_thd_options_is_detached_import |
Craig Tiller | 44ab6a5 | 2017-11-03 16:22:34 -0700 | [diff] [blame] | 832 | typedef int(*gpr_thd_options_is_joinable_type)(const gpr_thd_options* options); |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 833 | extern gpr_thd_options_is_joinable_type gpr_thd_options_is_joinable_import; |
| 834 | #define gpr_thd_options_is_joinable gpr_thd_options_is_joinable_import |
| 835 | typedef gpr_thd_id(*gpr_thd_currentid_type)(void); |
| 836 | extern gpr_thd_currentid_type gpr_thd_currentid_import; |
| 837 | #define gpr_thd_currentid gpr_thd_currentid_import |
| 838 | typedef void(*gpr_thd_join_type)(gpr_thd_id t); |
| 839 | extern gpr_thd_join_type gpr_thd_join_import; |
| 840 | #define gpr_thd_join gpr_thd_join_import |
David Garcia Quintas | 1399e46 | 2016-07-27 20:31:55 -0700 | [diff] [blame] | 841 | typedef gpr_timespec(*gpr_time_0_type)(gpr_clock_type type); |
| 842 | extern gpr_time_0_type gpr_time_0_import; |
| 843 | #define gpr_time_0 gpr_time_0_import |
| 844 | typedef gpr_timespec(*gpr_inf_future_type)(gpr_clock_type type); |
| 845 | extern gpr_inf_future_type gpr_inf_future_import; |
| 846 | #define gpr_inf_future gpr_inf_future_import |
| 847 | typedef gpr_timespec(*gpr_inf_past_type)(gpr_clock_type type); |
| 848 | extern gpr_inf_past_type gpr_inf_past_import; |
| 849 | #define gpr_inf_past gpr_inf_past_import |
| 850 | typedef void(*gpr_time_init_type)(void); |
| 851 | extern gpr_time_init_type gpr_time_init_import; |
| 852 | #define gpr_time_init gpr_time_init_import |
| 853 | typedef gpr_timespec(*gpr_now_type)(gpr_clock_type clock); |
| 854 | extern gpr_now_type gpr_now_import; |
| 855 | #define gpr_now gpr_now_import |
| 856 | typedef gpr_timespec(*gpr_convert_clock_type_type)(gpr_timespec t, gpr_clock_type target_clock); |
| 857 | extern gpr_convert_clock_type_type gpr_convert_clock_type_import; |
| 858 | #define gpr_convert_clock_type gpr_convert_clock_type_import |
| 859 | typedef int(*gpr_time_cmp_type)(gpr_timespec a, gpr_timespec b); |
| 860 | extern gpr_time_cmp_type gpr_time_cmp_import; |
| 861 | #define gpr_time_cmp gpr_time_cmp_import |
| 862 | typedef gpr_timespec(*gpr_time_max_type)(gpr_timespec a, gpr_timespec b); |
| 863 | extern gpr_time_max_type gpr_time_max_import; |
| 864 | #define gpr_time_max gpr_time_max_import |
| 865 | typedef gpr_timespec(*gpr_time_min_type)(gpr_timespec a, gpr_timespec b); |
| 866 | extern gpr_time_min_type gpr_time_min_import; |
| 867 | #define gpr_time_min gpr_time_min_import |
| 868 | typedef gpr_timespec(*gpr_time_add_type)(gpr_timespec a, gpr_timespec b); |
| 869 | extern gpr_time_add_type gpr_time_add_import; |
| 870 | #define gpr_time_add gpr_time_add_import |
| 871 | typedef gpr_timespec(*gpr_time_sub_type)(gpr_timespec a, gpr_timespec b); |
| 872 | extern gpr_time_sub_type gpr_time_sub_import; |
| 873 | #define gpr_time_sub gpr_time_sub_import |
| 874 | typedef gpr_timespec(*gpr_time_from_micros_type)(int64_t x, gpr_clock_type clock_type); |
| 875 | extern gpr_time_from_micros_type gpr_time_from_micros_import; |
| 876 | #define gpr_time_from_micros gpr_time_from_micros_import |
| 877 | typedef gpr_timespec(*gpr_time_from_nanos_type)(int64_t x, gpr_clock_type clock_type); |
| 878 | extern gpr_time_from_nanos_type gpr_time_from_nanos_import; |
| 879 | #define gpr_time_from_nanos gpr_time_from_nanos_import |
| 880 | typedef gpr_timespec(*gpr_time_from_millis_type)(int64_t x, gpr_clock_type clock_type); |
| 881 | extern gpr_time_from_millis_type gpr_time_from_millis_import; |
| 882 | #define gpr_time_from_millis gpr_time_from_millis_import |
| 883 | typedef gpr_timespec(*gpr_time_from_seconds_type)(int64_t x, gpr_clock_type clock_type); |
| 884 | extern gpr_time_from_seconds_type gpr_time_from_seconds_import; |
| 885 | #define gpr_time_from_seconds gpr_time_from_seconds_import |
| 886 | typedef gpr_timespec(*gpr_time_from_minutes_type)(int64_t x, gpr_clock_type clock_type); |
| 887 | extern gpr_time_from_minutes_type gpr_time_from_minutes_import; |
| 888 | #define gpr_time_from_minutes gpr_time_from_minutes_import |
| 889 | typedef gpr_timespec(*gpr_time_from_hours_type)(int64_t x, gpr_clock_type clock_type); |
| 890 | extern gpr_time_from_hours_type gpr_time_from_hours_import; |
| 891 | #define gpr_time_from_hours gpr_time_from_hours_import |
| 892 | typedef int32_t(*gpr_time_to_millis_type)(gpr_timespec timespec); |
| 893 | extern gpr_time_to_millis_type gpr_time_to_millis_import; |
| 894 | #define gpr_time_to_millis gpr_time_to_millis_import |
| 895 | typedef int(*gpr_time_similar_type)(gpr_timespec a, gpr_timespec b, gpr_timespec threshold); |
| 896 | extern gpr_time_similar_type gpr_time_similar_import; |
| 897 | #define gpr_time_similar gpr_time_similar_import |
| 898 | typedef void(*gpr_sleep_until_type)(gpr_timespec until); |
| 899 | extern gpr_sleep_until_type gpr_sleep_until_import; |
| 900 | #define gpr_sleep_until gpr_sleep_until_import |
| 901 | typedef double(*gpr_timespec_to_micros_type)(gpr_timespec t); |
| 902 | extern gpr_timespec_to_micros_type gpr_timespec_to_micros_import; |
| 903 | #define gpr_timespec_to_micros gpr_timespec_to_micros_import |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 904 | |
| 905 | void grpc_rb_load_imports(HMODULE library); |
| 906 | |
Yuchen Zeng | 12dfdc3 | 2016-04-26 22:05:41 -0700 | [diff] [blame] | 907 | #endif /* GPR_WINDOWS */ |
Nicolas "Pixel" Noble | d14b6ac | 2016-01-30 05:21:15 +0100 | [diff] [blame] | 908 | |
| 909 | #endif |