1 module interop.headers; 2 import core.stdc.config; 3 import core.stdc.stdarg: va_list; 4 import core.sys.posix.pthread; 5 static import core.simd; 6 static import std.conv; 7 8 struct Int128 { long lower; long upper; } 9 struct UInt128 { ulong lower; ulong upper; } 10 11 struct __locale_data { int dummy; } 12 13 14 15 alias _Bool = bool; 16 struct dpp { 17 static struct Opaque(int N) { 18 void[N] bytes; 19 } 20 21 static bool isEmpty(T)() { 22 return T.tupleof.length == 0; 23 } 24 static struct Move(T) { 25 T* ptr; 26 } 27 28 29 static auto move(T)(ref T value) { 30 return Move!T(&value); 31 } 32 mixin template EnumD(string name, T, string prefix) if(is(T == enum)) { 33 private static string _memberMixinStr(string member) { 34 import std.conv: text; 35 import std.array: replace; 36 return text(` `, member.replace(prefix, ""), ` = `, T.stringof, `.`, member, `,`); 37 } 38 private static string _enumMixinStr() { 39 import std.array: join; 40 string[] ret; 41 ret ~= "enum " ~ name ~ "{"; 42 static foreach(member; __traits(allMembers, T)) { 43 ret ~= _memberMixinStr(member); 44 } 45 ret ~= "}"; 46 return ret.join("\n"); 47 } 48 mixin(_enumMixinStr()); 49 } 50 } 51 52 extern(C) 53 { 54 alias int32_t = int; 55 alias uint32_t = uint; 56 alias uint8_t = ubyte; 57 alias wchar_t = int; 58 alias size_t = c_ulong; 59 alias ptrdiff_t = c_long; 60 alias fsfilcnt64_t = c_ulong; 61 alias fsblkcnt64_t = c_ulong; 62 alias blkcnt64_t = c_long; 63 alias fsfilcnt_t = c_ulong; 64 alias fsblkcnt_t = c_ulong; 65 alias blkcnt_t = c_long; 66 alias blksize_t = c_long; 67 alias register_t = c_long; 68 alias u_int64_t = c_ulong; 69 alias u_int32_t = uint; 70 alias u_int16_t = ushort; 71 alias u_int8_t = ubyte; 72 alias suseconds_t = c_long; 73 alias useconds_t = uint; 74 alias key_t = int; 75 alias caddr_t = char*; 76 alias daddr_t = int; 77 alias ssize_t = c_long; 78 alias id_t = uint; 79 alias off64_t = c_long; 80 alias off_t = c_long; 81 alias uid_t = uint; 82 alias nlink_t = c_ulong; 83 alias mode_t = uint; 84 alias gid_t = uint; 85 alias dev_t = c_ulong; 86 alias ino64_t = c_ulong; 87 alias ino_t = c_ulong; 88 alias loff_t = c_long; 89 alias u_quad_t = c_ulong; 90 alias quad_t = c_long; 91 alias u_long = c_ulong; 92 alias u_int = uint; 93 alias u_short = ushort; 94 alias u_char = ubyte; 95 96 void grpc_metadata_array_init(grpc_metadata_array*) @nogc nothrow; 97 void grpc_metadata_array_destroy(grpc_metadata_array*) @nogc nothrow; 98 void grpc_call_details_init(grpc_call_details*) @nogc nothrow; 99 void grpc_call_details_destroy(grpc_call_details*) @nogc nothrow; 100 void grpc_register_plugin(void function(), void function()) @nogc nothrow; 101 void grpc_init() @nogc nothrow; 102 void grpc_shutdown() @nogc nothrow; 103 int grpc_is_initialized() @nogc nothrow; 104 void grpc_shutdown_blocking() @nogc nothrow; 105 const(char)* grpc_version_string() @nogc nothrow; 106 const(char)* grpc_g_stands_for() @nogc nothrow; 107 const(grpc_completion_queue_factory)* grpc_completion_queue_factory_lookup(const(grpc_completion_queue_attributes)*) @nogc nothrow; 108 grpc_completion_queue* grpc_completion_queue_create_for_next(void*) @nogc nothrow; 109 grpc_completion_queue* grpc_completion_queue_create_for_pluck(void*) @nogc nothrow; 110 grpc_completion_queue* grpc_completion_queue_create_for_callback(grpc_experimental_completion_queue_functor*, void*) @nogc nothrow; 111 grpc_completion_queue* grpc_completion_queue_create(const(grpc_completion_queue_factory)*, const(grpc_completion_queue_attributes)*, void*) @nogc nothrow; 112 grpc_event grpc_completion_queue_next(grpc_completion_queue*, gpr_timespec, void*) @nogc nothrow; 113 grpc_event grpc_completion_queue_pluck(grpc_completion_queue*, void*, gpr_timespec, void*) @nogc nothrow; 114 void grpc_completion_queue_shutdown(grpc_completion_queue*) @nogc nothrow; 115 void grpc_completion_queue_destroy(grpc_completion_queue*) @nogc nothrow; 116 void grpc_completion_queue_thread_local_cache_init(grpc_completion_queue*) @nogc nothrow; 117 int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue*, void**, int*) @nogc nothrow; 118 grpc_connectivity_state grpc_channel_check_connectivity_state(grpc_channel*, int) @nogc nothrow; 119 int grpc_channel_num_external_connectivity_watchers(grpc_channel*) @nogc nothrow; 120 void grpc_channel_watch_connectivity_state(grpc_channel*, grpc_connectivity_state, gpr_timespec, grpc_completion_queue*, void*) @nogc nothrow; 121 int grpc_channel_support_connectivity_watcher(grpc_channel*) @nogc nothrow; 122 grpc_call* grpc_channel_create_call(grpc_channel*, grpc_call*, uint, grpc_completion_queue*, grpc_slice, const(grpc_slice)*, gpr_timespec, void*) @nogc nothrow; 123 void grpc_channel_ping(grpc_channel*, grpc_completion_queue*, void*, void*) @nogc nothrow; 124 void* grpc_channel_register_call(grpc_channel*, const(char)*, const(char)*, void*) @nogc nothrow; 125 grpc_call* grpc_channel_create_registered_call(grpc_channel*, grpc_call*, uint, grpc_completion_queue*, void*, gpr_timespec, void*) @nogc nothrow; 126 void* grpc_call_arena_alloc(grpc_call*, c_ulong) @nogc nothrow; 127 grpc_call_error grpc_call_start_batch(grpc_call*, const(grpc_op)*, c_ulong, void*, void*) @nogc nothrow; 128 char* grpc_call_get_peer(grpc_call*) @nogc nothrow; 129 struct census_context; 130 void grpc_census_call_set_context(grpc_call*, census_context*) @nogc nothrow; 131 census_context* grpc_census_call_get_context(grpc_call*) @nogc nothrow; 132 char* grpc_channel_get_target(grpc_channel*) @nogc nothrow; 133 void grpc_channel_get_info(grpc_channel*, const(grpc_channel_info)*) @nogc nothrow; 134 void grpc_channel_reset_connect_backoff(grpc_channel*) @nogc nothrow; 135 grpc_channel* grpc_insecure_channel_create(const(char)*, const(grpc_channel_args)*, void*) @nogc nothrow; 136 grpc_channel* grpc_lame_client_channel_create(const(char)*, grpc_status_code, const(char)*) @nogc nothrow; 137 void grpc_channel_destroy(grpc_channel*) @nogc nothrow; 138 grpc_call_error grpc_call_cancel(grpc_call*, void*) @nogc nothrow; 139 grpc_call_error grpc_call_cancel_with_status(grpc_call*, grpc_status_code, const(char)*, void*) @nogc nothrow; 140 void grpc_call_ref(grpc_call*) @nogc nothrow; 141 void grpc_call_unref(grpc_call*) @nogc nothrow; 142 grpc_call_error grpc_server_request_call(grpc_server*, grpc_call**, grpc_call_details*, grpc_metadata_array*, grpc_completion_queue*, grpc_completion_queue*, void*) @nogc nothrow; 143 alias grpc_server_register_method_payload_handling = _Anonymous_17; 144 enum _Anonymous_17 145 { 146 GRPC_SRM_PAYLOAD_NONE = 0, 147 GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER = 1, 148 } 149 enum GRPC_SRM_PAYLOAD_NONE = _Anonymous_17.GRPC_SRM_PAYLOAD_NONE; 150 enum GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER = _Anonymous_17.GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER; 151 void* grpc_server_register_method(grpc_server*, const(char)*, const(char)*, grpc_server_register_method_payload_handling, uint) @nogc nothrow; 152 grpc_call_error grpc_server_request_registered_call(grpc_server*, void*, grpc_call**, gpr_timespec*, grpc_metadata_array*, grpc_byte_buffer**, grpc_completion_queue*, grpc_completion_queue*, void*) @nogc nothrow; 153 grpc_server* grpc_server_create(const(grpc_channel_args)*, void*) @nogc nothrow; 154 void grpc_server_register_completion_queue(grpc_server*, grpc_completion_queue*, void*) @nogc nothrow; 155 int grpc_server_add_insecure_http2_port(grpc_server*, const(char)*) @nogc nothrow; 156 void grpc_server_start(grpc_server*) @nogc nothrow; 157 void grpc_server_shutdown_and_notify(grpc_server*, grpc_completion_queue*, void*) @nogc nothrow; 158 void grpc_server_cancel_all_calls(grpc_server*) @nogc nothrow; 159 void grpc_server_destroy(grpc_server*) @nogc nothrow; 160 int grpc_tracer_set_enabled(const(char)*, int) @nogc nothrow; 161 int grpc_header_key_is_legal(grpc_slice) @nogc nothrow; 162 int grpc_header_nonbin_value_is_legal(grpc_slice) @nogc nothrow; 163 int grpc_is_binary_header(grpc_slice) @nogc nothrow; 164 const(char)* grpc_call_error_to_string(grpc_call_error) @nogc nothrow; 165 grpc_resource_quota* grpc_resource_quota_create(const(char)*) @nogc nothrow; 166 void grpc_resource_quota_ref(grpc_resource_quota*) @nogc nothrow; 167 void grpc_resource_quota_unref(grpc_resource_quota*) @nogc nothrow; 168 void grpc_resource_quota_resize(grpc_resource_quota*, c_ulong) @nogc nothrow; 169 void grpc_resource_quota_set_max_threads(grpc_resource_quota*, int) @nogc nothrow; 170 const(grpc_arg_pointer_vtable)* grpc_resource_quota_arg_vtable() @nogc nothrow; 171 char* grpc_channelz_get_top_channels(c_long) @nogc nothrow; 172 char* grpc_channelz_get_servers(c_long) @nogc nothrow; 173 char* grpc_channelz_get_server(c_long) @nogc nothrow; 174 char* grpc_channelz_get_server_sockets(c_long, c_long, c_long) @nogc nothrow; 175 char* grpc_channelz_get_channel(c_long) @nogc nothrow; 176 char* grpc_channelz_get_subchannel(c_long) @nogc nothrow; 177 char* grpc_channelz_get_socket(c_long) @nogc nothrow; 178 struct grpc_auth_context; 179 struct grpc_auth_property_iterator 180 { 181 const(grpc_auth_context)* ctx; 182 c_ulong index; 183 const(char)* name; 184 } 185 struct grpc_auth_property 186 { 187 char* name; 188 char* value; 189 c_ulong value_length; 190 } 191 const(grpc_auth_property)* grpc_auth_property_iterator_next(grpc_auth_property_iterator*) @nogc nothrow; 192 grpc_auth_property_iterator grpc_auth_context_property_iterator(const(grpc_auth_context)*) @nogc nothrow; 193 grpc_auth_property_iterator grpc_auth_context_peer_identity(const(grpc_auth_context)*) @nogc nothrow; 194 grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(const(grpc_auth_context)*, const(char)*) @nogc nothrow; 195 const(char)* grpc_auth_context_peer_identity_property_name(const(grpc_auth_context)*) @nogc nothrow; 196 int grpc_auth_context_peer_is_authenticated(const(grpc_auth_context)*) @nogc nothrow; 197 grpc_auth_context* grpc_call_auth_context(grpc_call*) @nogc nothrow; 198 void grpc_auth_context_release(grpc_auth_context*) @nogc nothrow; 199 void grpc_auth_context_add_property(grpc_auth_context*, const(char)*, const(char)*, c_ulong) @nogc nothrow; 200 void grpc_auth_context_add_cstring_property(grpc_auth_context*, const(char)*, const(char)*) @nogc nothrow; 201 int grpc_auth_context_set_peer_identity_property_name(grpc_auth_context*, const(char)*) @nogc nothrow; 202 struct grpc_ssl_session_cache; 203 grpc_ssl_session_cache* grpc_ssl_session_cache_create_lru(c_ulong) @nogc nothrow; 204 void grpc_ssl_session_cache_destroy(grpc_ssl_session_cache*) @nogc nothrow; 205 grpc_arg grpc_ssl_session_cache_create_channel_arg(grpc_ssl_session_cache*) @nogc nothrow; 206 struct grpc_channel_credentials; 207 void grpc_channel_credentials_release(grpc_channel_credentials*) @nogc nothrow; 208 grpc_channel_credentials* grpc_google_default_credentials_create() @nogc nothrow; 209 alias grpc_ssl_roots_override_callback = grpc_ssl_roots_override_result function(char**); 210 void grpc_set_ssl_roots_override_callback(grpc_ssl_roots_override_result function(char**)) @nogc nothrow; 211 struct grpc_ssl_pem_key_cert_pair 212 { 213 const(char)* private_key; 214 const(char)* cert_chain; 215 } 216 struct verify_peer_options 217 { 218 int function(const(char)*, const(char)*, void*) verify_peer_callback; 219 void* verify_peer_callback_userdata; 220 void function(void*) verify_peer_destruct; 221 } 222 struct grpc_ssl_verify_peer_options 223 { 224 int function(const(char)*, const(char)*, void*) verify_peer_callback; 225 void* verify_peer_callback_userdata; 226 void function(void*) verify_peer_destruct; 227 } 228 grpc_channel_credentials* grpc_ssl_credentials_create(const(char)*, grpc_ssl_pem_key_cert_pair*, const(verify_peer_options)*, void*) @nogc nothrow; 229 grpc_channel_credentials* grpc_ssl_credentials_create_ex(const(char)*, grpc_ssl_pem_key_cert_pair*, const(grpc_ssl_verify_peer_options)*, void*) @nogc nothrow; 230 struct grpc_call_credentials; 231 void grpc_call_credentials_release(grpc_call_credentials*) @nogc nothrow; 232 grpc_channel_credentials* grpc_composite_channel_credentials_create(grpc_channel_credentials*, grpc_call_credentials*, void*) @nogc nothrow; 233 grpc_call_credentials* grpc_composite_call_credentials_create(grpc_call_credentials*, grpc_call_credentials*, void*) @nogc nothrow; 234 grpc_call_credentials* grpc_google_compute_engine_credentials_create(void*) @nogc nothrow; 235 gpr_timespec grpc_max_auth_token_lifetime() @nogc nothrow; 236 grpc_call_credentials* grpc_service_account_jwt_access_credentials_create(const(char)*, gpr_timespec, void*) @nogc nothrow; 237 grpc_call_credentials* grpc_google_refresh_token_credentials_create(const(char)*, void*) @nogc nothrow; 238 grpc_call_credentials* grpc_access_token_credentials_create(const(char)*, void*) @nogc nothrow; 239 grpc_call_credentials* grpc_google_iam_credentials_create(const(char)*, const(char)*, void*) @nogc nothrow; 240 struct grpc_sts_credentials_options 241 { 242 const(char)* token_exchange_service_uri; 243 const(char)* resource; 244 const(char)* audience; 245 const(char)* scope_; 246 const(char)* requested_token_type; 247 const(char)* subject_token_path; 248 const(char)* subject_token_type; 249 const(char)* actor_token_path; 250 const(char)* actor_token_type; 251 } 252 grpc_call_credentials* grpc_sts_credentials_create(const(grpc_sts_credentials_options)*, void*) @nogc nothrow; 253 alias grpc_credentials_plugin_metadata_cb = void function(void*, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*); 254 struct grpc_auth_metadata_context 255 { 256 const(char)* service_url; 257 const(char)* method_name; 258 const(grpc_auth_context)* channel_auth_context; 259 void* reserved; 260 } 261 int strfromf32x(char*, c_ulong, const(char)*, double) @nogc nothrow; 262 struct grpc_metadata_credentials_plugin 263 { 264 int function(void*, grpc_auth_metadata_context, void function(void*, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*), void*, grpc_metadata[4], c_ulong*, grpc_status_code*, const(char)**) get_metadata; 265 void function(void*) destroy; 266 void* state; 267 const(char)* type; 268 } 269 grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(grpc_metadata_credentials_plugin, grpc_security_level, void*) @nogc nothrow; 270 grpc_channel* grpc_secure_channel_create(grpc_channel_credentials*, const(char)*, const(grpc_channel_args)*, void*) @nogc nothrow; 271 struct grpc_server_credentials; 272 void grpc_server_credentials_release(grpc_server_credentials*) @nogc nothrow; 273 struct grpc_ssl_server_certificate_config; 274 grpc_ssl_server_certificate_config* grpc_ssl_server_certificate_config_create(const(char)*, const(grpc_ssl_pem_key_cert_pair)*, c_ulong) @nogc nothrow; 275 void grpc_ssl_server_certificate_config_destroy(grpc_ssl_server_certificate_config*) @nogc nothrow; 276 alias grpc_ssl_server_certificate_config_callback = grpc_ssl_certificate_config_reload_status function(void*, grpc_ssl_server_certificate_config**); 277 grpc_server_credentials* grpc_ssl_server_credentials_create(const(char)*, grpc_ssl_pem_key_cert_pair*, c_ulong, int, void*) @nogc nothrow; 278 grpc_server_credentials* grpc_ssl_server_credentials_create_ex(const(char)*, grpc_ssl_pem_key_cert_pair*, c_ulong, grpc_ssl_client_certificate_request_type, void*) @nogc nothrow; 279 struct grpc_ssl_server_credentials_options; 280 grpc_ssl_server_credentials_options* grpc_ssl_server_credentials_create_options_using_config(grpc_ssl_client_certificate_request_type, grpc_ssl_server_certificate_config*) @nogc nothrow; 281 grpc_ssl_server_credentials_options* grpc_ssl_server_credentials_create_options_using_config_fetcher(grpc_ssl_client_certificate_request_type, grpc_ssl_certificate_config_reload_status function(void*, grpc_ssl_server_certificate_config**), void*) @nogc nothrow; 282 void grpc_ssl_server_credentials_options_destroy(grpc_ssl_server_credentials_options*) @nogc nothrow; 283 grpc_server_credentials* grpc_ssl_server_credentials_create_with_options(grpc_ssl_server_credentials_options*) @nogc nothrow; 284 int grpc_server_add_secure_http2_port(grpc_server*, const(char)*, grpc_server_credentials*) @nogc nothrow; 285 grpc_call_error grpc_call_set_credentials(grpc_call*, grpc_call_credentials*) @nogc nothrow; 286 alias grpc_process_auth_metadata_done_cb = void function(void*, const(grpc_metadata)*, c_ulong, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*); 287 struct grpc_auth_metadata_processor 288 { 289 void function(void*, grpc_auth_context*, const(grpc_metadata)*, c_ulong, void function(void*, const(grpc_metadata)*, c_ulong, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*), void*) process; 290 void function(void*) destroy; 291 void* state; 292 } 293 void grpc_server_credentials_set_auth_metadata_processor(grpc_server_credentials*, grpc_auth_metadata_processor) @nogc nothrow; 294 struct grpc_alts_credentials_options; 295 grpc_alts_credentials_options* grpc_alts_credentials_client_options_create() @nogc nothrow; 296 grpc_alts_credentials_options* grpc_alts_credentials_server_options_create() @nogc nothrow; 297 void grpc_alts_credentials_client_options_add_target_service_account(grpc_alts_credentials_options*, const(char)*) @nogc nothrow; 298 void grpc_alts_credentials_options_destroy(grpc_alts_credentials_options*) @nogc nothrow; 299 grpc_channel_credentials* grpc_alts_credentials_create(const(grpc_alts_credentials_options)*) @nogc nothrow; 300 grpc_server_credentials* grpc_alts_server_credentials_create(const(grpc_alts_credentials_options)*) @nogc nothrow; 301 grpc_channel_credentials* grpc_local_credentials_create(grpc_local_connect_type) @nogc nothrow; 302 grpc_server_credentials* grpc_local_server_credentials_create(grpc_local_connect_type) @nogc nothrow; 303 struct grpc_tls_key_materials_config; 304 struct grpc_tls_credential_reload_config; 305 struct grpc_tls_server_authorization_check_config; 306 struct grpc_tls_credentials_options; 307 grpc_tls_credentials_options* grpc_tls_credentials_options_create() @nogc nothrow; 308 int grpc_tls_credentials_options_set_cert_request_type(grpc_tls_credentials_options*, grpc_ssl_client_certificate_request_type) @nogc nothrow; 309 int grpc_tls_credentials_options_set_server_verification_option(grpc_tls_credentials_options*, grpc_tls_server_verification_option) @nogc nothrow; 310 int grpc_tls_credentials_options_set_key_materials_config(grpc_tls_credentials_options*, grpc_tls_key_materials_config*) @nogc nothrow; 311 int grpc_tls_credentials_options_set_credential_reload_config(grpc_tls_credentials_options*, grpc_tls_credential_reload_config*) @nogc nothrow; 312 int grpc_tls_credentials_options_set_server_authorization_check_config(grpc_tls_credentials_options*, grpc_tls_server_authorization_check_config*) @nogc nothrow; 313 grpc_tls_key_materials_config* grpc_tls_key_materials_config_create() @nogc nothrow; 314 int grpc_tls_key_materials_config_set_key_materials(grpc_tls_key_materials_config*, const(char)*, const(grpc_ssl_pem_key_cert_pair)**, c_ulong) @nogc nothrow; 315 int grpc_tls_key_materials_config_set_version(grpc_tls_key_materials_config*, int) @nogc nothrow; 316 int grpc_tls_key_materials_config_get_version(grpc_tls_key_materials_config*) @nogc nothrow; 317 struct grpc_tls_credential_reload_arg 318 { 319 void function(grpc_tls_credential_reload_arg*) cb; 320 void* cb_user_data; 321 grpc_tls_key_materials_config* key_materials_config; 322 grpc_ssl_certificate_config_reload_status status; 323 const(char)* error_details; 324 grpc_tls_credential_reload_config* config; 325 void* context; 326 void function(void*) destroy_context; 327 } 328 alias grpc_tls_on_credential_reload_done_cb = void function(grpc_tls_credential_reload_arg*); 329 grpc_tls_credential_reload_config* grpc_tls_credential_reload_config_create(const(void)*, int function(void*, grpc_tls_credential_reload_arg*), void function(void*, grpc_tls_credential_reload_arg*), void function(void*)) @nogc nothrow; 330 struct grpc_tls_server_authorization_check_arg 331 { 332 void function(grpc_tls_server_authorization_check_arg*) cb; 333 void* cb_user_data; 334 int success; 335 const(char)* target_name; 336 const(char)* peer_cert; 337 const(char)* peer_cert_full_chain; 338 grpc_status_code status; 339 const(char)* error_details; 340 grpc_tls_server_authorization_check_config* config; 341 void* context; 342 void function(void*) destroy_context; 343 } 344 alias grpc_tls_on_server_authorization_check_done_cb = void function(grpc_tls_server_authorization_check_arg*); 345 grpc_tls_server_authorization_check_config* grpc_tls_server_authorization_check_config_create(const(void)*, int function(void*, grpc_tls_server_authorization_check_arg*), void function(void*, grpc_tls_server_authorization_check_arg*), void function(void*)) @nogc nothrow; 346 grpc_channel_credentials* grpc_tls_credentials_create(grpc_tls_credentials_options*) @nogc nothrow; 347 grpc_server_credentials* grpc_tls_server_credentials_create(grpc_tls_credentials_options*) @nogc nothrow; 348 int strfromf64(char*, c_ulong, const(char)*, double) @nogc nothrow; 349 alias grpc_ssl_roots_override_result = _Anonymous_18; 350 enum _Anonymous_18 351 { 352 GRPC_SSL_ROOTS_OVERRIDE_OK = 0, 353 GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY = 1, 354 GRPC_SSL_ROOTS_OVERRIDE_FAIL = 2, 355 } 356 enum GRPC_SSL_ROOTS_OVERRIDE_OK = _Anonymous_18.GRPC_SSL_ROOTS_OVERRIDE_OK; 357 enum GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY = _Anonymous_18.GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY; 358 enum GRPC_SSL_ROOTS_OVERRIDE_FAIL = _Anonymous_18.GRPC_SSL_ROOTS_OVERRIDE_FAIL; 359 alias grpc_ssl_certificate_config_reload_status = _Anonymous_19; 360 enum _Anonymous_19 361 { 362 GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED = 0, 363 GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW = 1, 364 GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL = 2, 365 } 366 enum GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED = _Anonymous_19.GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED; 367 enum GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW = _Anonymous_19.GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW; 368 enum GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL = _Anonymous_19.GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL; 369 alias grpc_ssl_client_certificate_request_type = _Anonymous_20; 370 enum _Anonymous_20 371 { 372 GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE = 0, 373 GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = 1, 374 GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY = 2, 375 GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = 3, 376 GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY = 4, 377 } 378 enum GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE = _Anonymous_20.GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE; 379 enum GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY; 380 enum GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY; 381 enum GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY; 382 enum GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY; 383 alias grpc_security_level = _Anonymous_21; 384 enum _Anonymous_21 385 { 386 GRPC_SECURITY_MIN = 0, 387 GRPC_SECURITY_NONE = 0, 388 GRPC_INTEGRITY_ONLY = 1, 389 GRPC_PRIVACY_AND_INTEGRITY = 2, 390 GRPC_SECURITY_MAX = 2, 391 } 392 enum GRPC_SECURITY_MIN = _Anonymous_21.GRPC_SECURITY_MIN; 393 enum GRPC_SECURITY_NONE = _Anonymous_21.GRPC_SECURITY_NONE; 394 enum GRPC_INTEGRITY_ONLY = _Anonymous_21.GRPC_INTEGRITY_ONLY; 395 enum GRPC_PRIVACY_AND_INTEGRITY = _Anonymous_21.GRPC_PRIVACY_AND_INTEGRITY; 396 enum GRPC_SECURITY_MAX = _Anonymous_21.GRPC_SECURITY_MAX; 397 alias grpc_tls_server_verification_option = _Anonymous_22; 398 enum _Anonymous_22 399 { 400 GRPC_TLS_SERVER_VERIFICATION = 0, 401 GRPC_TLS_SKIP_HOSTNAME_VERIFICATION = 1, 402 GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION = 2, 403 } 404 enum GRPC_TLS_SERVER_VERIFICATION = _Anonymous_22.GRPC_TLS_SERVER_VERIFICATION; 405 enum GRPC_TLS_SKIP_HOSTNAME_VERIFICATION = _Anonymous_22.GRPC_TLS_SKIP_HOSTNAME_VERIFICATION; 406 enum GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION = _Anonymous_22.GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION; 407 alias grpc_local_connect_type = _Anonymous_23; 408 enum _Anonymous_23 409 { 410 UDS = 0, 411 LOCAL_TCP = 1, 412 } 413 enum UDS = _Anonymous_23.UDS; 414 enum LOCAL_TCP = _Anonymous_23.LOCAL_TCP; 415 c_long gpr_atm_no_barrier_clamped_add(c_long*, c_long, c_long, c_long) @nogc nothrow; 416 alias gpr_atm = c_long; 417 static int gpr_atm_no_barrier_cas(c_long*, c_long, c_long) @nogc nothrow; 418 static int gpr_atm_acq_cas(c_long*, c_long, c_long) @nogc nothrow; 419 static int gpr_atm_rel_cas(c_long*, c_long, c_long) @nogc nothrow; 420 static int gpr_atm_full_cas(c_long*, c_long, c_long) @nogc nothrow; 421 grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice*, c_ulong) @nogc nothrow; 422 grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(grpc_slice*, c_ulong, grpc_compression_algorithm) @nogc nothrow; 423 grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer*) @nogc nothrow; 424 c_ulong grpc_byte_buffer_length(grpc_byte_buffer*) @nogc nothrow; 425 void grpc_byte_buffer_destroy(grpc_byte_buffer*) @nogc nothrow; 426 int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader*, grpc_byte_buffer*) @nogc nothrow; 427 void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader*) @nogc nothrow; 428 int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader*, grpc_slice*) @nogc nothrow; 429 int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader*, grpc_slice**) @nogc nothrow; 430 grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader*) @nogc nothrow; 431 grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(grpc_byte_buffer_reader*) @nogc nothrow; 432 struct grpc_byte_buffer 433 { 434 void* reserved; 435 grpc_byte_buffer_type type; 436 union grpc_byte_buffer_data 437 { 438 static struct _Anonymous_24 439 { 440 void*[8] reserved; 441 } 442 _Anonymous_24 reserved; 443 struct grpc_compressed_buffer 444 { 445 grpc_compression_algorithm compression; 446 grpc_slice_buffer slice_buffer; 447 } 448 grpc_compressed_buffer raw; 449 } 450 grpc_byte_buffer_data data; 451 } 452 struct grpc_byte_buffer_reader 453 { 454 grpc_byte_buffer* buffer_in; 455 grpc_byte_buffer* buffer_out; 456 union grpc_byte_buffer_reader_current 457 { 458 uint index; 459 } 460 grpc_byte_buffer_reader_current current; 461 } 462 alias grpc_compression_algorithm = _Anonymous_25; 463 enum _Anonymous_25 464 { 465 GRPC_COMPRESS_NONE = 0, 466 GRPC_COMPRESS_DEFLATE = 1, 467 GRPC_COMPRESS_GZIP = 2, 468 GRPC_COMPRESS_STREAM_GZIP = 3, 469 GRPC_COMPRESS_ALGORITHMS_COUNT = 4, 470 } 471 enum GRPC_COMPRESS_NONE = _Anonymous_25.GRPC_COMPRESS_NONE; 472 enum GRPC_COMPRESS_DEFLATE = _Anonymous_25.GRPC_COMPRESS_DEFLATE; 473 enum GRPC_COMPRESS_GZIP = _Anonymous_25.GRPC_COMPRESS_GZIP; 474 enum GRPC_COMPRESS_STREAM_GZIP = _Anonymous_25.GRPC_COMPRESS_STREAM_GZIP; 475 enum GRPC_COMPRESS_ALGORITHMS_COUNT = _Anonymous_25.GRPC_COMPRESS_ALGORITHMS_COUNT; 476 alias grpc_compression_level = _Anonymous_26; 477 enum _Anonymous_26 478 { 479 GRPC_COMPRESS_LEVEL_NONE = 0, 480 GRPC_COMPRESS_LEVEL_LOW = 1, 481 GRPC_COMPRESS_LEVEL_MED = 2, 482 GRPC_COMPRESS_LEVEL_HIGH = 3, 483 GRPC_COMPRESS_LEVEL_COUNT = 4, 484 } 485 enum GRPC_COMPRESS_LEVEL_NONE = _Anonymous_26.GRPC_COMPRESS_LEVEL_NONE; 486 enum GRPC_COMPRESS_LEVEL_LOW = _Anonymous_26.GRPC_COMPRESS_LEVEL_LOW; 487 enum GRPC_COMPRESS_LEVEL_MED = _Anonymous_26.GRPC_COMPRESS_LEVEL_MED; 488 enum GRPC_COMPRESS_LEVEL_HIGH = _Anonymous_26.GRPC_COMPRESS_LEVEL_HIGH; 489 enum GRPC_COMPRESS_LEVEL_COUNT = _Anonymous_26.GRPC_COMPRESS_LEVEL_COUNT; 490 struct grpc_compression_options 491 { 492 uint enabled_algorithms_bitset; 493 struct grpc_compression_options_default_level 494 { 495 int is_set; 496 grpc_compression_level level; 497 } 498 grpc_compression_options_default_level default_level; 499 struct grpc_compression_options_default_algorithm 500 { 501 int is_set; 502 grpc_compression_algorithm algorithm; 503 } 504 grpc_compression_options_default_algorithm default_algorithm; 505 } 506 alias grpc_connectivity_state = _Anonymous_27; 507 enum _Anonymous_27 508 { 509 GRPC_CHANNEL_IDLE = 0, 510 GRPC_CHANNEL_CONNECTING = 1, 511 GRPC_CHANNEL_READY = 2, 512 GRPC_CHANNEL_TRANSIENT_FAILURE = 3, 513 GRPC_CHANNEL_SHUTDOWN = 4, 514 } 515 enum GRPC_CHANNEL_IDLE = _Anonymous_27.GRPC_CHANNEL_IDLE; 516 enum GRPC_CHANNEL_CONNECTING = _Anonymous_27.GRPC_CHANNEL_CONNECTING; 517 enum GRPC_CHANNEL_READY = _Anonymous_27.GRPC_CHANNEL_READY; 518 enum GRPC_CHANNEL_TRANSIENT_FAILURE = _Anonymous_27.GRPC_CHANNEL_TRANSIENT_FAILURE; 519 enum GRPC_CHANNEL_SHUTDOWN = _Anonymous_27.GRPC_CHANNEL_SHUTDOWN; 520 alias gpr_clock_type = _Anonymous_28; 521 enum _Anonymous_28 522 { 523 GPR_CLOCK_MONOTONIC = 0, 524 GPR_CLOCK_REALTIME = 1, 525 GPR_CLOCK_PRECISE = 2, 526 GPR_TIMESPAN = 3, 527 } 528 enum GPR_CLOCK_MONOTONIC = _Anonymous_28.GPR_CLOCK_MONOTONIC; 529 enum GPR_CLOCK_REALTIME = _Anonymous_28.GPR_CLOCK_REALTIME; 530 enum GPR_CLOCK_PRECISE = _Anonymous_28.GPR_CLOCK_PRECISE; 531 enum GPR_TIMESPAN = _Anonymous_28.GPR_TIMESPAN; 532 struct gpr_timespec 533 { 534 c_long tv_sec; 535 int tv_nsec; 536 gpr_clock_type clock_type; 537 } 538 alias grpc_byte_buffer_type = _Anonymous_29; 539 enum _Anonymous_29 540 { 541 GRPC_BB_RAW = 0, 542 } 543 enum GRPC_BB_RAW = _Anonymous_29.GRPC_BB_RAW; 544 struct grpc_completion_queue; 545 struct grpc_alarm; 546 struct grpc_channel; 547 struct grpc_server; 548 struct grpc_call; 549 struct grpc_socket_mutator; 550 struct grpc_socket_factory; 551 alias grpc_arg_type = _Anonymous_30; 552 enum _Anonymous_30 553 { 554 GRPC_ARG_STRING = 0, 555 GRPC_ARG_INTEGER = 1, 556 GRPC_ARG_POINTER = 2, 557 } 558 enum GRPC_ARG_STRING = _Anonymous_30.GRPC_ARG_STRING; 559 enum GRPC_ARG_INTEGER = _Anonymous_30.GRPC_ARG_INTEGER; 560 enum GRPC_ARG_POINTER = _Anonymous_30.GRPC_ARG_POINTER; 561 struct grpc_arg_pointer_vtable 562 { 563 void* function(void*) copy; 564 void function(void*) destroy; 565 int function(void*, void*) cmp; 566 } 567 struct grpc_arg 568 { 569 grpc_arg_type type; 570 char* key; 571 union grpc_arg_value 572 { 573 char* string; 574 int integer; 575 struct grpc_arg_pointer 576 { 577 void* p; 578 const(grpc_arg_pointer_vtable)* vtable; 579 } 580 grpc_arg_pointer pointer; 581 } 582 grpc_arg_value value; 583 } 584 struct grpc_channel_args 585 { 586 c_ulong num_args; 587 grpc_arg* args; 588 } 589 alias uintmax_t = c_ulong; 590 alias intmax_t = c_long; 591 alias uintptr_t = c_ulong; 592 alias intptr_t = c_long; 593 alias uint_fast64_t = c_ulong; 594 alias uint_fast32_t = c_ulong; 595 alias uint_fast16_t = c_ulong; 596 alias uint_fast8_t = ubyte; 597 alias int_fast64_t = c_long; 598 alias int_fast32_t = c_long; 599 alias int_fast16_t = c_long; 600 alias int_fast8_t = byte; 601 enum grpc_call_error 602 { 603 GRPC_CALL_OK = 0, 604 GRPC_CALL_ERROR = 1, 605 GRPC_CALL_ERROR_NOT_ON_SERVER = 2, 606 GRPC_CALL_ERROR_NOT_ON_CLIENT = 3, 607 GRPC_CALL_ERROR_ALREADY_ACCEPTED = 4, 608 GRPC_CALL_ERROR_ALREADY_INVOKED = 5, 609 GRPC_CALL_ERROR_NOT_INVOKED = 6, 610 GRPC_CALL_ERROR_ALREADY_FINISHED = 7, 611 GRPC_CALL_ERROR_TOO_MANY_OPERATIONS = 8, 612 GRPC_CALL_ERROR_INVALID_FLAGS = 9, 613 GRPC_CALL_ERROR_INVALID_METADATA = 10, 614 GRPC_CALL_ERROR_INVALID_MESSAGE = 11, 615 GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE = 12, 616 GRPC_CALL_ERROR_BATCH_TOO_BIG = 13, 617 GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH = 14, 618 GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN = 15, 619 } 620 enum GRPC_CALL_OK = grpc_call_error.GRPC_CALL_OK; 621 enum GRPC_CALL_ERROR = grpc_call_error.GRPC_CALL_ERROR; 622 enum GRPC_CALL_ERROR_NOT_ON_SERVER = grpc_call_error.GRPC_CALL_ERROR_NOT_ON_SERVER; 623 enum GRPC_CALL_ERROR_NOT_ON_CLIENT = grpc_call_error.GRPC_CALL_ERROR_NOT_ON_CLIENT; 624 enum GRPC_CALL_ERROR_ALREADY_ACCEPTED = grpc_call_error.GRPC_CALL_ERROR_ALREADY_ACCEPTED; 625 enum GRPC_CALL_ERROR_ALREADY_INVOKED = grpc_call_error.GRPC_CALL_ERROR_ALREADY_INVOKED; 626 enum GRPC_CALL_ERROR_NOT_INVOKED = grpc_call_error.GRPC_CALL_ERROR_NOT_INVOKED; 627 enum GRPC_CALL_ERROR_ALREADY_FINISHED = grpc_call_error.GRPC_CALL_ERROR_ALREADY_FINISHED; 628 enum GRPC_CALL_ERROR_TOO_MANY_OPERATIONS = grpc_call_error.GRPC_CALL_ERROR_TOO_MANY_OPERATIONS; 629 enum GRPC_CALL_ERROR_INVALID_FLAGS = grpc_call_error.GRPC_CALL_ERROR_INVALID_FLAGS; 630 enum GRPC_CALL_ERROR_INVALID_METADATA = grpc_call_error.GRPC_CALL_ERROR_INVALID_METADATA; 631 enum GRPC_CALL_ERROR_INVALID_MESSAGE = grpc_call_error.GRPC_CALL_ERROR_INVALID_MESSAGE; 632 enum GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE = grpc_call_error.GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE; 633 enum GRPC_CALL_ERROR_BATCH_TOO_BIG = grpc_call_error.GRPC_CALL_ERROR_BATCH_TOO_BIG; 634 enum GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH = grpc_call_error.GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH; 635 enum GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN = grpc_call_error.GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN; 636 alias uint_least64_t = c_ulong; 637 alias uint_least32_t = uint; 638 alias uint_least16_t = ushort; 639 alias uint_least8_t = ubyte; 640 alias int_least64_t = c_long; 641 alias int_least32_t = int; 642 alias int_least16_t = short; 643 alias int_least8_t = byte; 644 struct grpc_metadata 645 { 646 grpc_slice key; 647 grpc_slice value; 648 uint flags; 649 static struct _Anonymous_31 650 { 651 void*[4] obfuscated; 652 } 653 _Anonymous_31 internal_data; 654 } 655 enum grpc_completion_type 656 { 657 GRPC_QUEUE_SHUTDOWN = 0, 658 GRPC_QUEUE_TIMEOUT = 1, 659 GRPC_OP_COMPLETE = 2, 660 } 661 enum GRPC_QUEUE_SHUTDOWN = grpc_completion_type.GRPC_QUEUE_SHUTDOWN; 662 enum GRPC_QUEUE_TIMEOUT = grpc_completion_type.GRPC_QUEUE_TIMEOUT; 663 enum GRPC_OP_COMPLETE = grpc_completion_type.GRPC_OP_COMPLETE; 664 struct grpc_event 665 { 666 grpc_completion_type type; 667 int success; 668 void* tag; 669 } 670 struct grpc_metadata_array 671 { 672 c_ulong count; 673 c_ulong capacity; 674 grpc_metadata* metadata; 675 } 676 struct grpc_call_details 677 { 678 grpc_slice method; 679 grpc_slice host; 680 gpr_timespec deadline; 681 uint flags; 682 void* reserved; 683 } 684 alias grpc_op_type = _Anonymous_32; 685 enum _Anonymous_32 686 { 687 GRPC_OP_SEND_INITIAL_METADATA = 0, 688 GRPC_OP_SEND_MESSAGE = 1, 689 GRPC_OP_SEND_CLOSE_FROM_CLIENT = 2, 690 GRPC_OP_SEND_STATUS_FROM_SERVER = 3, 691 GRPC_OP_RECV_INITIAL_METADATA = 4, 692 GRPC_OP_RECV_MESSAGE = 5, 693 GRPC_OP_RECV_STATUS_ON_CLIENT = 6, 694 GRPC_OP_RECV_CLOSE_ON_SERVER = 7, 695 } 696 enum GRPC_OP_SEND_INITIAL_METADATA = _Anonymous_32.GRPC_OP_SEND_INITIAL_METADATA; 697 enum GRPC_OP_SEND_MESSAGE = _Anonymous_32.GRPC_OP_SEND_MESSAGE; 698 enum GRPC_OP_SEND_CLOSE_FROM_CLIENT = _Anonymous_32.GRPC_OP_SEND_CLOSE_FROM_CLIENT; 699 enum GRPC_OP_SEND_STATUS_FROM_SERVER = _Anonymous_32.GRPC_OP_SEND_STATUS_FROM_SERVER; 700 enum GRPC_OP_RECV_INITIAL_METADATA = _Anonymous_32.GRPC_OP_RECV_INITIAL_METADATA; 701 enum GRPC_OP_RECV_MESSAGE = _Anonymous_32.GRPC_OP_RECV_MESSAGE; 702 enum GRPC_OP_RECV_STATUS_ON_CLIENT = _Anonymous_32.GRPC_OP_RECV_STATUS_ON_CLIENT; 703 enum GRPC_OP_RECV_CLOSE_ON_SERVER = _Anonymous_32.GRPC_OP_RECV_CLOSE_ON_SERVER; 704 struct grpc_op 705 { 706 grpc_op_type op; 707 uint flags; 708 void* reserved; 709 union grpc_op_data 710 { 711 static struct _Anonymous_33 712 { 713 void*[8] reserved; 714 } 715 _Anonymous_33 reserved; 716 struct grpc_op_send_initial_metadata 717 { 718 c_ulong count; 719 grpc_metadata* metadata; 720 struct grpc_op_send_initial_metadata_maybe_compression_level 721 { 722 ubyte is_set; 723 grpc_compression_level level; 724 } 725 grpc_op_send_initial_metadata_maybe_compression_level maybe_compression_level; 726 } 727 grpc_op_send_initial_metadata send_initial_metadata; 728 struct grpc_op_send_message 729 { 730 grpc_byte_buffer* send_message; 731 } 732 grpc_op_send_message send_message; 733 struct grpc_op_send_status_from_server 734 { 735 c_ulong trailing_metadata_count; 736 grpc_metadata* trailing_metadata; 737 grpc_status_code status; 738 grpc_slice* status_details; 739 } 740 grpc_op_send_status_from_server send_status_from_server; 741 struct grpc_op_recv_initial_metadata 742 { 743 grpc_metadata_array* recv_initial_metadata; 744 } 745 grpc_op_recv_initial_metadata recv_initial_metadata; 746 struct grpc_op_recv_message 747 { 748 grpc_byte_buffer** recv_message; 749 } 750 grpc_op_recv_message recv_message; 751 struct grpc_op_recv_status_on_client 752 { 753 grpc_metadata_array* trailing_metadata; 754 grpc_status_code* status; 755 grpc_slice* status_details; 756 const(char)** error_string; 757 } 758 grpc_op_recv_status_on_client recv_status_on_client; 759 struct grpc_op_recv_close_on_server 760 { 761 int* cancelled; 762 } 763 grpc_op_recv_close_on_server recv_close_on_server; 764 } 765 grpc_op_data data; 766 } 767 struct grpc_channel_info 768 { 769 char** lb_policy_name; 770 char** service_config_json; 771 } 772 struct grpc_resource_quota; 773 alias grpc_cq_polling_type = _Anonymous_34; 774 enum _Anonymous_34 775 { 776 GRPC_CQ_DEFAULT_POLLING = 0, 777 GRPC_CQ_NON_LISTENING = 1, 778 GRPC_CQ_NON_POLLING = 2, 779 } 780 enum GRPC_CQ_DEFAULT_POLLING = _Anonymous_34.GRPC_CQ_DEFAULT_POLLING; 781 enum GRPC_CQ_NON_LISTENING = _Anonymous_34.GRPC_CQ_NON_LISTENING; 782 enum GRPC_CQ_NON_POLLING = _Anonymous_34.GRPC_CQ_NON_POLLING; 783 alias grpc_cq_completion_type = _Anonymous_35; 784 enum _Anonymous_35 785 { 786 GRPC_CQ_NEXT = 0, 787 GRPC_CQ_PLUCK = 1, 788 GRPC_CQ_CALLBACK = 2, 789 } 790 enum GRPC_CQ_NEXT = _Anonymous_35.GRPC_CQ_NEXT; 791 enum GRPC_CQ_PLUCK = _Anonymous_35.GRPC_CQ_PLUCK; 792 enum GRPC_CQ_CALLBACK = _Anonymous_35.GRPC_CQ_CALLBACK; 793 struct grpc_experimental_completion_queue_functor 794 { 795 void function(grpc_experimental_completion_queue_functor*, int) functor_run; 796 int inlineable; 797 int internal_success; 798 grpc_experimental_completion_queue_functor* internal_next; 799 } 800 struct grpc_completion_queue_attributes 801 { 802 int version_; 803 grpc_cq_completion_type cq_completion_type; 804 grpc_cq_polling_type cq_polling_type; 805 grpc_experimental_completion_queue_functor* cq_shutdown_cb; 806 } 807 struct grpc_completion_queue_factory; 808 enum gpr_log_severity 809 { 810 GPR_LOG_SEVERITY_DEBUG = 0, 811 GPR_LOG_SEVERITY_INFO = 1, 812 GPR_LOG_SEVERITY_ERROR = 2, 813 } 814 enum GPR_LOG_SEVERITY_DEBUG = gpr_log_severity.GPR_LOG_SEVERITY_DEBUG; 815 enum GPR_LOG_SEVERITY_INFO = gpr_log_severity.GPR_LOG_SEVERITY_INFO; 816 enum GPR_LOG_SEVERITY_ERROR = gpr_log_severity.GPR_LOG_SEVERITY_ERROR; 817 const(char)* gpr_log_severity_string(gpr_log_severity) @nogc nothrow; 818 void gpr_log(const(char)*, int, gpr_log_severity, const(char)*, ...) @nogc nothrow; 819 int gpr_should_log(gpr_log_severity) @nogc nothrow; 820 void gpr_log_message(const(char)*, int, gpr_log_severity, const(char)*) @nogc nothrow; 821 void gpr_set_log_verbosity(gpr_log_severity) @nogc nothrow; 822 void gpr_log_verbosity_init() @nogc nothrow; 823 struct gpr_log_func_args 824 { 825 const(char)* file; 826 int line; 827 gpr_log_severity severity; 828 const(char)* message; 829 } 830 alias gpr_log_func = void function(gpr_log_func_args*); 831 void gpr_set_log_function(void function(gpr_log_func_args*)) @nogc nothrow; 832 struct grpc_slice 833 { 834 grpc_slice_refcount* refcount; 835 union grpc_slice_data 836 { 837 struct grpc_slice_refcounted 838 { 839 c_ulong length; 840 ubyte* bytes; 841 } 842 grpc_slice_refcounted refcounted; 843 struct grpc_slice_inlined 844 { 845 ubyte length; 846 ubyte[23] bytes; 847 } 848 grpc_slice_inlined inlined; 849 } 850 grpc_slice_data data; 851 } 852 struct grpc_slice_refcount; 853 struct grpc_slice_buffer 854 { 855 grpc_slice* base_slices; 856 grpc_slice* slices; 857 c_ulong count; 858 c_ulong capacity; 859 c_ulong length; 860 grpc_slice[8] inlined; 861 } 862 alias grpc_status_code = _Anonymous_36; 863 enum _Anonymous_36 864 { 865 GRPC_STATUS_OK = 0, 866 GRPC_STATUS_CANCELLED = 1, 867 GRPC_STATUS_UNKNOWN = 2, 868 GRPC_STATUS_INVALID_ARGUMENT = 3, 869 GRPC_STATUS_DEADLINE_EXCEEDED = 4, 870 GRPC_STATUS_NOT_FOUND = 5, 871 GRPC_STATUS_ALREADY_EXISTS = 6, 872 GRPC_STATUS_PERMISSION_DENIED = 7, 873 GRPC_STATUS_UNAUTHENTICATED = 16, 874 GRPC_STATUS_RESOURCE_EXHAUSTED = 8, 875 GRPC_STATUS_FAILED_PRECONDITION = 9, 876 GRPC_STATUS_ABORTED = 10, 877 GRPC_STATUS_OUT_OF_RANGE = 11, 878 GRPC_STATUS_UNIMPLEMENTED = 12, 879 GRPC_STATUS_INTERNAL = 13, 880 GRPC_STATUS_UNAVAILABLE = 14, 881 GRPC_STATUS_DATA_LOSS = 15, 882 GRPC_STATUS__DO_NOT_USE = -1, 883 } 884 enum GRPC_STATUS_OK = _Anonymous_36.GRPC_STATUS_OK; 885 enum GRPC_STATUS_CANCELLED = _Anonymous_36.GRPC_STATUS_CANCELLED; 886 enum GRPC_STATUS_UNKNOWN = _Anonymous_36.GRPC_STATUS_UNKNOWN; 887 enum GRPC_STATUS_INVALID_ARGUMENT = _Anonymous_36.GRPC_STATUS_INVALID_ARGUMENT; 888 enum GRPC_STATUS_DEADLINE_EXCEEDED = _Anonymous_36.GRPC_STATUS_DEADLINE_EXCEEDED; 889 enum GRPC_STATUS_NOT_FOUND = _Anonymous_36.GRPC_STATUS_NOT_FOUND; 890 enum GRPC_STATUS_ALREADY_EXISTS = _Anonymous_36.GRPC_STATUS_ALREADY_EXISTS; 891 enum GRPC_STATUS_PERMISSION_DENIED = _Anonymous_36.GRPC_STATUS_PERMISSION_DENIED; 892 enum GRPC_STATUS_UNAUTHENTICATED = _Anonymous_36.GRPC_STATUS_UNAUTHENTICATED; 893 enum GRPC_STATUS_RESOURCE_EXHAUSTED = _Anonymous_36.GRPC_STATUS_RESOURCE_EXHAUSTED; 894 enum GRPC_STATUS_FAILED_PRECONDITION = _Anonymous_36.GRPC_STATUS_FAILED_PRECONDITION; 895 enum GRPC_STATUS_ABORTED = _Anonymous_36.GRPC_STATUS_ABORTED; 896 enum GRPC_STATUS_OUT_OF_RANGE = _Anonymous_36.GRPC_STATUS_OUT_OF_RANGE; 897 enum GRPC_STATUS_UNIMPLEMENTED = _Anonymous_36.GRPC_STATUS_UNIMPLEMENTED; 898 enum GRPC_STATUS_INTERNAL = _Anonymous_36.GRPC_STATUS_INTERNAL; 899 enum GRPC_STATUS_UNAVAILABLE = _Anonymous_36.GRPC_STATUS_UNAVAILABLE; 900 enum GRPC_STATUS_DATA_LOSS = _Anonymous_36.GRPC_STATUS_DATA_LOSS; 901 enum GRPC_STATUS__DO_NOT_USE = _Anonymous_36.GRPC_STATUS__DO_NOT_USE; 902 int pthread_spin_lock(int*) @nogc nothrow; 903 struct gpr_event 904 { 905 c_long state; 906 } 907 struct gpr_refcount 908 { 909 c_long count; 910 } 911 struct gpr_stats_counter 912 { 913 c_long value; 914 } 915 int pthread_spin_destroy(int*) @nogc nothrow; 916 alias gpr_mu = pthread_mutex_t; 917 alias gpr_cv = pthread_cond_t; 918 alias gpr_once = int; 919 int pthread_spin_init(int*, int) @nogc nothrow; 920 grpc_slice grpc_slice_ref(grpc_slice) @nogc nothrow; 921 void grpc_slice_unref(grpc_slice) @nogc nothrow; 922 grpc_slice grpc_slice_copy(grpc_slice) @nogc nothrow; 923 grpc_slice grpc_slice_new(void*, c_ulong, void function(void*)) @nogc nothrow; 924 grpc_slice grpc_slice_new_with_user_data(void*, c_ulong, void function(void*), void*) @nogc nothrow; 925 grpc_slice grpc_slice_new_with_len(void*, c_ulong, void function(void*, c_ulong)) @nogc nothrow; 926 grpc_slice grpc_slice_malloc(c_ulong) @nogc nothrow; 927 grpc_slice grpc_slice_malloc_large(c_ulong) @nogc nothrow; 928 grpc_slice grpc_slice_intern(grpc_slice) @nogc nothrow; 929 grpc_slice grpc_slice_from_copied_string(const(char)*) @nogc nothrow; 930 grpc_slice grpc_slice_from_copied_buffer(const(char)*, c_ulong) @nogc nothrow; 931 grpc_slice grpc_slice_from_static_string(const(char)*) @nogc nothrow; 932 grpc_slice grpc_slice_from_static_buffer(const(void)*, c_ulong) @nogc nothrow; 933 grpc_slice grpc_slice_sub(grpc_slice, c_ulong, c_ulong) @nogc nothrow; 934 grpc_slice grpc_slice_sub_no_ref(grpc_slice, c_ulong, c_ulong) @nogc nothrow; 935 grpc_slice grpc_slice_split_tail(grpc_slice*, c_ulong) @nogc nothrow; 936 alias grpc_slice_ref_whom = _Anonymous_37; 937 enum _Anonymous_37 938 { 939 GRPC_SLICE_REF_TAIL = 1, 940 GRPC_SLICE_REF_HEAD = 2, 941 GRPC_SLICE_REF_BOTH = 3, 942 } 943 enum GRPC_SLICE_REF_TAIL = _Anonymous_37.GRPC_SLICE_REF_TAIL; 944 enum GRPC_SLICE_REF_HEAD = _Anonymous_37.GRPC_SLICE_REF_HEAD; 945 enum GRPC_SLICE_REF_BOTH = _Anonymous_37.GRPC_SLICE_REF_BOTH; 946 grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice*, c_ulong, grpc_slice_ref_whom) @nogc nothrow; 947 grpc_slice grpc_slice_split_head(grpc_slice*, c_ulong) @nogc nothrow; 948 grpc_slice grpc_empty_slice() @nogc nothrow; 949 uint grpc_slice_default_hash_impl(grpc_slice) @nogc nothrow; 950 int grpc_slice_default_eq_impl(grpc_slice, grpc_slice) @nogc nothrow; 951 int grpc_slice_eq(grpc_slice, grpc_slice) @nogc nothrow; 952 int grpc_slice_cmp(grpc_slice, grpc_slice) @nogc nothrow; 953 int grpc_slice_str_cmp(grpc_slice, const(char)*) @nogc nothrow; 954 int grpc_slice_buf_start_eq(grpc_slice, const(void)*, c_ulong) @nogc nothrow; 955 int grpc_slice_rchr(grpc_slice, char) @nogc nothrow; 956 int grpc_slice_chr(grpc_slice, char) @nogc nothrow; 957 int grpc_slice_slice(grpc_slice, grpc_slice) @nogc nothrow; 958 uint grpc_slice_hash(grpc_slice) @nogc nothrow; 959 int grpc_slice_is_equivalent(grpc_slice, grpc_slice) @nogc nothrow; 960 grpc_slice grpc_slice_dup(grpc_slice) @nogc nothrow; 961 char* grpc_slice_to_c_string(grpc_slice) @nogc nothrow; 962 void grpc_slice_buffer_init(grpc_slice_buffer*) @nogc nothrow; 963 void grpc_slice_buffer_destroy(grpc_slice_buffer*) @nogc nothrow; 964 void grpc_slice_buffer_add(grpc_slice_buffer*, grpc_slice) @nogc nothrow; 965 c_ulong grpc_slice_buffer_add_indexed(grpc_slice_buffer*, grpc_slice) @nogc nothrow; 966 void grpc_slice_buffer_addn(grpc_slice_buffer*, grpc_slice*, c_ulong) @nogc nothrow; 967 ubyte* grpc_slice_buffer_tiny_add(grpc_slice_buffer*, c_ulong) @nogc nothrow; 968 void grpc_slice_buffer_pop(grpc_slice_buffer*) @nogc nothrow; 969 void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer*) @nogc nothrow; 970 void grpc_slice_buffer_swap(grpc_slice_buffer*, grpc_slice_buffer*) @nogc nothrow; 971 void grpc_slice_buffer_move_into(grpc_slice_buffer*, grpc_slice_buffer*) @nogc nothrow; 972 void grpc_slice_buffer_trim_end(grpc_slice_buffer*, c_ulong, grpc_slice_buffer*) @nogc nothrow; 973 void grpc_slice_buffer_move_first(grpc_slice_buffer*, c_ulong, grpc_slice_buffer*) @nogc nothrow; 974 void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer*, c_ulong, grpc_slice_buffer*) @nogc nothrow; 975 void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer*, c_ulong, void*) @nogc nothrow; 976 grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer*) @nogc nothrow; 977 void grpc_slice_buffer_undo_take_first(grpc_slice_buffer*, grpc_slice) @nogc nothrow; 978 int pthread_condattr_setclock(pthread_condattr_t*, int) @nogc nothrow; 979 void* gpr_malloc(c_ulong) @nogc nothrow; 980 void* gpr_zalloc(c_ulong) @nogc nothrow; 981 void gpr_free(void*) @nogc nothrow; 982 void* gpr_realloc(void*, c_ulong) @nogc nothrow; 983 void* gpr_malloc_aligned(c_ulong, c_ulong) @nogc nothrow; 984 void gpr_free_aligned(void*) @nogc nothrow; 985 int pthread_condattr_getclock(const(pthread_condattr_t)*, int*) @nogc nothrow; 986 char* gpr_strdup(const(char)*) @nogc nothrow; 987 int gpr_asprintf(char**, const(char)*, ...) @nogc nothrow; 988 void gpr_mu_init(pthread_mutex_t*) @nogc nothrow; 989 void gpr_mu_destroy(pthread_mutex_t*) @nogc nothrow; 990 void gpr_mu_lock(pthread_mutex_t*) @nogc nothrow; 991 void gpr_mu_unlock(pthread_mutex_t*) @nogc nothrow; 992 int gpr_mu_trylock(pthread_mutex_t*) @nogc nothrow; 993 void gpr_cv_init(pthread_cond_t*) @nogc nothrow; 994 void gpr_cv_destroy(pthread_cond_t*) @nogc nothrow; 995 int gpr_cv_wait(pthread_cond_t*, pthread_mutex_t*, gpr_timespec) @nogc nothrow; 996 void gpr_cv_signal(pthread_cond_t*) @nogc nothrow; 997 void gpr_cv_broadcast(pthread_cond_t*) @nogc nothrow; 998 void gpr_once_init(int*, void function()) @nogc nothrow; 999 void gpr_event_init(gpr_event*) @nogc nothrow; 1000 void gpr_event_set(gpr_event*, void*) @nogc nothrow; 1001 void* gpr_event_get(gpr_event*) @nogc nothrow; 1002 void* gpr_event_wait(gpr_event*, gpr_timespec) @nogc nothrow; 1003 void gpr_ref_init(gpr_refcount*, int) @nogc nothrow; 1004 void gpr_ref(gpr_refcount*) @nogc nothrow; 1005 void gpr_ref_non_zero(gpr_refcount*) @nogc nothrow; 1006 void gpr_refn(gpr_refcount*, int) @nogc nothrow; 1007 int gpr_unref(gpr_refcount*) @nogc nothrow; 1008 int gpr_ref_is_unique(gpr_refcount*) @nogc nothrow; 1009 void gpr_stats_init(gpr_stats_counter*, c_long) @nogc nothrow; 1010 void gpr_stats_inc(gpr_stats_counter*, c_long) @nogc nothrow; 1011 c_long gpr_stats_read(const(gpr_stats_counter)*) @nogc nothrow; 1012 alias gpr_thd_id = c_ulong; 1013 c_ulong gpr_thd_currentid() @nogc nothrow; 1014 gpr_timespec gpr_time_0(gpr_clock_type) @nogc nothrow; 1015 gpr_timespec gpr_inf_future(gpr_clock_type) @nogc nothrow; 1016 gpr_timespec gpr_inf_past(gpr_clock_type) @nogc nothrow; 1017 int pthread_condattr_setpshared(pthread_condattr_t*, int) @nogc nothrow; 1018 int pthread_condattr_getpshared(const(pthread_condattr_t)*, int*) @nogc nothrow; 1019 void gpr_time_init() @nogc nothrow; 1020 gpr_timespec gpr_now(gpr_clock_type) @nogc nothrow; 1021 gpr_timespec gpr_convert_clock_type(gpr_timespec, gpr_clock_type) @nogc nothrow; 1022 int gpr_time_cmp(gpr_timespec, gpr_timespec) @nogc nothrow; 1023 gpr_timespec gpr_time_max(gpr_timespec, gpr_timespec) @nogc nothrow; 1024 gpr_timespec gpr_time_min(gpr_timespec, gpr_timespec) @nogc nothrow; 1025 gpr_timespec gpr_time_add(gpr_timespec, gpr_timespec) @nogc nothrow; 1026 gpr_timespec gpr_time_sub(gpr_timespec, gpr_timespec) @nogc nothrow; 1027 gpr_timespec gpr_time_from_micros(c_long, gpr_clock_type) @nogc nothrow; 1028 gpr_timespec gpr_time_from_nanos(c_long, gpr_clock_type) @nogc nothrow; 1029 gpr_timespec gpr_time_from_millis(c_long, gpr_clock_type) @nogc nothrow; 1030 gpr_timespec gpr_time_from_seconds(c_long, gpr_clock_type) @nogc nothrow; 1031 gpr_timespec gpr_time_from_minutes(c_long, gpr_clock_type) @nogc nothrow; 1032 gpr_timespec gpr_time_from_hours(c_long, gpr_clock_type) @nogc nothrow; 1033 int gpr_time_to_millis(gpr_timespec) @nogc nothrow; 1034 int gpr_time_similar(gpr_timespec, gpr_timespec, gpr_timespec) @nogc nothrow; 1035 void gpr_sleep_until(gpr_timespec) @nogc nothrow; 1036 double gpr_timespec_to_micros(gpr_timespec) @nogc nothrow; 1037 1038 static if(!is(typeof(GPR_US_PER_MS))) { 1039 enum GPR_US_PER_MS = 1000; 1040 } 1041 1042 1043 1044 1045 static if(!is(typeof(GPR_NS_PER_US))) { 1046 enum GPR_NS_PER_US = 1000; 1047 } 1048 1049 1050 1051 1052 static if(!is(typeof(GPR_NS_PER_MS))) { 1053 enum GPR_NS_PER_MS = 1000000; 1054 } 1055 1056 1057 1058 1059 static if(!is(typeof(GPR_NS_PER_SEC))) { 1060 enum GPR_NS_PER_SEC = 1000000000; 1061 } 1062 1063 1064 1065 1066 static if(!is(typeof(GPR_US_PER_SEC))) { 1067 enum GPR_US_PER_SEC = 1000000; 1068 } 1069 1070 1071 1072 1073 static if(!is(typeof(GPR_MS_PER_SEC))) { 1074 enum GPR_MS_PER_SEC = 1000; 1075 } 1076 static if(!is(typeof(GRPC_SLICE_BUFFER_INLINE_ELEMENTS))) { 1077 enum GRPC_SLICE_BUFFER_INLINE_ELEMENTS = 8; 1078 } 1079 static if(!is(typeof(GRPC_ALLOW_EXCEPTIONS))) { 1080 enum GRPC_ALLOW_EXCEPTIONS = 0; 1081 } 1082 1083 1084 1085 1086 1087 1088 static if(!is(typeof(GPR_HAS_ATTRIBUTE_WEAK))) { 1089 enum GPR_HAS_ATTRIBUTE_WEAK = 1; 1090 } 1091 1092 1093 1094 1095 1096 1097 static if(!is(typeof(GPR_HAS_ATTRIBUTE_NOINLINE))) { 1098 enum GPR_HAS_ATTRIBUTE_NOINLINE = 1; 1099 } 1100 static if(!is(typeof(GRPC_IF_NAMETOINDEX))) { 1101 enum GRPC_IF_NAMETOINDEX = 1; 1102 } 1103 1104 1105 1106 1107 static if(!is(typeof(GRPC_ARES))) { 1108 enum GRPC_ARES = 1; 1109 } 1110 1111 1112 1113 1114 static if(!is(typeof(GPR_MAX_ALIGNMENT))) { 1115 enum GPR_MAX_ALIGNMENT = 16; 1116 } 1117 1118 1119 1120 1121 1122 1123 static if(!is(typeof(GPR_CACHELINE_SIZE_LOG))) { 1124 enum GPR_CACHELINE_SIZE_LOG = 6; 1125 } 1126 1127 1128 1129 1130 static if(!is(typeof(_SCHED_H))) { 1131 enum _SCHED_H = 1; 1132 } 1133 1134 1135 1136 1137 static if(!is(typeof(GPR_CYCLE_COUNTER_FALLBACK))) { 1138 enum GPR_CYCLE_COUNTER_FALLBACK = 1; 1139 } 1140 static if(!is(typeof(GPR_LINUX_PTHREAD_NAME))) { 1141 enum GPR_LINUX_PTHREAD_NAME = 1; 1142 } 1143 1144 1145 1146 1147 static if(!is(typeof(GPR_POSIX_CRASH_HANDLER))) { 1148 enum GPR_POSIX_CRASH_HANDLER = 1; 1149 } 1150 1151 1152 1153 1154 static if(!is(typeof(GPR_ARCH_64))) { 1155 enum GPR_ARCH_64 = 1; 1156 } 1157 1158 1159 1160 1161 static if(!is(typeof(GPR_GETPID_IN_UNISTD_H))) { 1162 enum GPR_GETPID_IN_UNISTD_H = 1; 1163 } 1164 1165 1166 1167 1168 static if(!is(typeof(GPR_HAS_PTHREAD_H))) { 1169 enum GPR_HAS_PTHREAD_H = 1; 1170 } 1171 1172 1173 1174 1175 1176 1177 static if(!is(typeof(GPR_POSIX_TIME))) { 1178 enum GPR_POSIX_TIME = 1; 1179 } 1180 1181 1182 1183 1184 static if(!is(typeof(GPR_POSIX_SYNC))) { 1185 enum GPR_POSIX_SYNC = 1; 1186 } 1187 static if(!is(typeof(GPR_POSIX_SUBPROCESS))) { 1188 enum GPR_POSIX_SUBPROCESS = 1; 1189 } 1190 1191 1192 1193 1194 static if(!is(typeof(GPR_POSIX_STRING))) { 1195 enum GPR_POSIX_STRING = 1; 1196 } 1197 1198 1199 1200 1201 static if(!is(typeof(GPR_POSIX_TMPFILE))) { 1202 enum GPR_POSIX_TMPFILE = 1; 1203 } 1204 1205 1206 1207 1208 static if(!is(typeof(GPR_LINUX_ENV))) { 1209 enum GPR_LINUX_ENV = 1; 1210 } 1211 1212 1213 1214 1215 static if(!is(typeof(GPR_SUPPORT_CHANNELS_FROM_FD))) { 1216 enum GPR_SUPPORT_CHANNELS_FROM_FD = 1; 1217 } 1218 1219 1220 1221 1222 1223 1224 static if(!is(typeof(GPR_LINUX))) { 1225 enum GPR_LINUX = 1; 1226 } 1227 1228 1229 1230 1231 static if(!is(typeof(GPR_GCC_TLS))) { 1232 enum GPR_GCC_TLS = 1; 1233 } 1234 1235 1236 1237 1238 static if(!is(typeof(GPR_GCC_ATOMIC))) { 1239 enum GPR_GCC_ATOMIC = 1; 1240 } 1241 1242 1243 1244 1245 static if(!is(typeof(GPR_CPU_LINUX))) { 1246 enum GPR_CPU_LINUX = 1; 1247 } 1248 static if(!is(typeof(GPR_PLATFORM_STRING))) { 1249 enum GPR_PLATFORM_STRING = "linux"; 1250 } 1251 1252 1253 1254 1255 static if(!is(typeof(GRPC_USE_ABSL))) { 1256 enum GRPC_USE_ABSL = 1; 1257 } 1258 static if(!is(typeof(_STDC_PREDEF_H))) { 1259 enum _STDC_PREDEF_H = 1; 1260 } 1261 1262 1263 1264 1265 static if(!is(typeof(_STDINT_H))) { 1266 enum _STDINT_H = 1; 1267 } 1268 1269 1270 1271 1272 1273 1274 static if(!is(typeof(GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE))) { 1275 enum GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE = 2; 1276 } 1277 1278 1279 1280 1281 static if(!is(typeof(GRPC_CQ_CURRENT_VERSION))) { 1282 enum GRPC_CQ_CURRENT_VERSION = 2; 1283 } 1284 static if(!is(typeof(GRPC_ARG_CHANNEL_ID))) { 1285 enum GRPC_ARG_CHANNEL_ID = "grpc.channel_id"; 1286 } 1287 1288 1289 1290 1291 static if(!is(typeof(GRPC_ARG_CHANNEL_POOL_DOMAIN))) { 1292 enum GRPC_ARG_CHANNEL_POOL_DOMAIN = "grpc.channel_pooling_domain"; 1293 } 1294 1295 1296 1297 1298 static if(!is(typeof(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL))) { 1299 enum GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL = "grpc.use_local_subchannel_pool"; 1300 } 1301 1302 1303 1304 1305 static if(!is(typeof(GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS))) { 1306 enum GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS = "grpc.dns_ares_query_timeout"; 1307 } 1308 1309 1310 1311 1312 static if(!is(typeof(GRPC_ARG_DNS_ENABLE_SRV_QUERIES))) { 1313 enum GRPC_ARG_DNS_ENABLE_SRV_QUERIES = "grpc.dns_enable_srv_queries"; 1314 } 1315 1316 1317 1318 1319 static if(!is(typeof(GRPC_ARG_INHIBIT_HEALTH_CHECKING))) { 1320 enum GRPC_ARG_INHIBIT_HEALTH_CHECKING = "grpc.inhibit_health_checking"; 1321 } 1322 1323 1324 1325 1326 static if(!is(typeof(GRPC_ARG_SURFACE_USER_AGENT))) { 1327 enum GRPC_ARG_SURFACE_USER_AGENT = "grpc.surface_user_agent"; 1328 } 1329 1330 1331 1332 1333 static if(!is(typeof(GRPC_ARG_ENABLE_HTTP_PROXY))) { 1334 enum GRPC_ARG_ENABLE_HTTP_PROXY = "grpc.enable_http_proxy"; 1335 } 1336 1337 1338 1339 1340 static if(!is(typeof(GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER))) { 1341 enum GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER = "grpc.disable_client_authority_filter"; 1342 } 1343 1344 1345 1346 1347 static if(!is(typeof(GRPC_ARG_MOBILE_LOG_CONTEXT))) { 1348 enum GRPC_ARG_MOBILE_LOG_CONTEXT = "grpc.mobile_log_context"; 1349 } 1350 1351 1352 1353 1354 static if(!is(typeof(GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE))) { 1355 enum GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE = "grpc.per_rpc_retry_buffer_size"; 1356 } 1357 1358 1359 1360 1361 static if(!is(typeof(GRPC_ARG_ENABLE_RETRIES))) { 1362 enum GRPC_ARG_ENABLE_RETRIES = "grpc.enable_retries"; 1363 } 1364 1365 1366 1367 1368 1369 1370 static if(!is(typeof(GRPC_ARG_OPTIMIZATION_TARGET))) { 1371 enum GRPC_ARG_OPTIMIZATION_TARGET = "grpc.optimization_target"; 1372 } 1373 1374 1375 1376 1377 static if(!is(typeof(GRPC_ARG_WORKAROUND_CRONET_COMPRESSION))) { 1378 enum GRPC_ARG_WORKAROUND_CRONET_COMPRESSION = "grpc.workaround.cronet_compression"; 1379 } 1380 1381 1382 1383 1384 static if(!is(typeof(GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS))) { 1385 enum GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS = "grpc.xds_resource_does_not_exist_timeout_ms"; 1386 } 1387 1388 1389 1390 1391 static if(!is(typeof(GRPC_ARG_XDS_FAILOVER_TIMEOUT_MS))) { 1392 enum GRPC_ARG_XDS_FAILOVER_TIMEOUT_MS = "grpc.xds_failover_timeout_ms"; 1393 } 1394 static if(!is(typeof(GRPC_ARG_LOCALITY_RETENTION_INTERVAL_MS))) { 1395 enum GRPC_ARG_LOCALITY_RETENTION_INTERVAL_MS = "grpc.xds_locality_retention_interval_ms"; 1396 } 1397 static if(!is(typeof(GRPC_ARG_XDS_FALLBACK_TIMEOUT_MS))) { 1398 enum GRPC_ARG_XDS_FALLBACK_TIMEOUT_MS = "grpc.xds_fallback_timeout_ms"; 1399 } 1400 static if(!is(typeof(GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS))) { 1401 enum GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS = "grpc.grpclb_fallback_timeout_ms"; 1402 } 1403 static if(!is(typeof(GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS))) { 1404 enum GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS = "grpc.grpclb_call_timeout_ms"; 1405 } 1406 static if(!is(typeof(GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS))) { 1407 enum GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS = "grpc.experimental.tcp_tx_zerocopy_max_simultaneous_sends"; 1408 } 1409 static if(!is(typeof(GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD))) { 1410 enum GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD = "grpc.experimental.tcp_tx_zerocopy_send_bytes_threshold"; 1411 } 1412 static if(!is(typeof(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED))) { 1413 enum GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED = "grpc.experimental.tcp_tx_zerocopy_enabled"; 1414 } 1415 static if(!is(typeof(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE))) { 1416 enum GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE = "grpc.experimental.tcp_max_read_chunk_size"; 1417 } 1418 1419 1420 1421 1422 1423 1424 static if(!is(typeof(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE))) { 1425 enum GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE = "grpc.experimental.tcp_min_read_chunk_size"; 1426 } 1427 static if(!is(typeof(GRPC_TCP_DEFAULT_READ_SLICE_SIZE))) { 1428 enum GRPC_TCP_DEFAULT_READ_SLICE_SIZE = 8192; 1429 } 1430 1431 1432 1433 1434 static if(!is(typeof(INT8_WIDTH))) { 1435 enum INT8_WIDTH = 8; 1436 } 1437 1438 1439 1440 1441 static if(!is(typeof(UINT8_WIDTH))) { 1442 enum UINT8_WIDTH = 8; 1443 } 1444 1445 1446 1447 1448 static if(!is(typeof(INT16_WIDTH))) { 1449 enum INT16_WIDTH = 16; 1450 } 1451 1452 1453 1454 1455 static if(!is(typeof(UINT16_WIDTH))) { 1456 enum UINT16_WIDTH = 16; 1457 } 1458 1459 1460 1461 1462 static if(!is(typeof(INT32_WIDTH))) { 1463 enum INT32_WIDTH = 32; 1464 } 1465 1466 1467 1468 1469 static if(!is(typeof(UINT32_WIDTH))) { 1470 enum UINT32_WIDTH = 32; 1471 } 1472 1473 1474 1475 1476 static if(!is(typeof(INT64_WIDTH))) { 1477 enum INT64_WIDTH = 64; 1478 } 1479 1480 1481 1482 1483 static if(!is(typeof(UINT64_WIDTH))) { 1484 enum UINT64_WIDTH = 64; 1485 } 1486 1487 1488 1489 1490 static if(!is(typeof(INT_LEAST8_WIDTH))) { 1491 enum INT_LEAST8_WIDTH = 8; 1492 } 1493 1494 1495 1496 1497 static if(!is(typeof(UINT_LEAST8_WIDTH))) { 1498 enum UINT_LEAST8_WIDTH = 8; 1499 } 1500 1501 1502 1503 1504 static if(!is(typeof(INT_LEAST16_WIDTH))) { 1505 enum INT_LEAST16_WIDTH = 16; 1506 } 1507 1508 1509 1510 1511 static if(!is(typeof(UINT_LEAST16_WIDTH))) { 1512 enum UINT_LEAST16_WIDTH = 16; 1513 } 1514 1515 1516 1517 1518 static if(!is(typeof(INT_LEAST32_WIDTH))) { 1519 enum INT_LEAST32_WIDTH = 32; 1520 } 1521 1522 1523 1524 1525 static if(!is(typeof(UINT_LEAST32_WIDTH))) { 1526 enum UINT_LEAST32_WIDTH = 32; 1527 } 1528 1529 1530 1531 1532 static if(!is(typeof(INT_LEAST64_WIDTH))) { 1533 enum INT_LEAST64_WIDTH = 64; 1534 } 1535 1536 1537 1538 1539 static if(!is(typeof(UINT_LEAST64_WIDTH))) { 1540 enum UINT_LEAST64_WIDTH = 64; 1541 } 1542 1543 1544 1545 1546 static if(!is(typeof(INT_FAST8_WIDTH))) { 1547 enum INT_FAST8_WIDTH = 8; 1548 } 1549 1550 1551 1552 1553 static if(!is(typeof(UINT_FAST8_WIDTH))) { 1554 enum UINT_FAST8_WIDTH = 8; 1555 } 1556 static if(!is(typeof(INT_FAST64_WIDTH))) { 1557 enum INT_FAST64_WIDTH = 64; 1558 } 1559 1560 1561 1562 1563 static if(!is(typeof(UINT_FAST64_WIDTH))) { 1564 enum UINT_FAST64_WIDTH = 64; 1565 } 1566 static if(!is(typeof(INTMAX_WIDTH))) { 1567 enum INTMAX_WIDTH = 64; 1568 } 1569 1570 1571 1572 1573 static if(!is(typeof(UINTMAX_WIDTH))) { 1574 enum UINTMAX_WIDTH = 64; 1575 } 1576 1577 1578 1579 1580 1581 1582 static if(!is(typeof(SIG_ATOMIC_WIDTH))) { 1583 enum SIG_ATOMIC_WIDTH = 32; 1584 } 1585 1586 1587 1588 1589 1590 1591 static if(!is(typeof(WCHAR_WIDTH))) { 1592 enum WCHAR_WIDTH = 32; 1593 } 1594 1595 1596 1597 1598 static if(!is(typeof(WINT_WIDTH))) { 1599 enum WINT_WIDTH = 32; 1600 } 1601 1602 1603 1604 1605 static if(!is(typeof(GRPC_ARG_TCP_READ_CHUNK_SIZE))) { 1606 enum GRPC_ARG_TCP_READ_CHUNK_SIZE = "grpc.experimental.tcp_read_chunk_size"; 1607 } 1608 1609 1610 1611 1612 1613 1614 static if(!is(typeof(GRPC_ARG_USE_CRONET_PACKET_COALESCING))) { 1615 enum GRPC_ARG_USE_CRONET_PACKET_COALESCING = "grpc.use_cronet_packet_coalescing"; 1616 } 1617 1618 1619 1620 1621 static if(!is(typeof(GRPC_ARG_ENABLE_CHANNELZ))) { 1622 enum GRPC_ARG_ENABLE_CHANNELZ = "grpc.enable_channelz"; 1623 } 1624 1625 1626 1627 1628 static if(!is(typeof(_STDLIB_H))) { 1629 enum _STDLIB_H = 1; 1630 } 1631 1632 1633 1634 1635 static if(!is(typeof(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE))) { 1636 enum GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE = "grpc.max_channel_trace_event_memory_per_node"; 1637 } 1638 1639 1640 1641 1642 static if(!is(typeof(GRPC_ARG_SOCKET_FACTORY))) { 1643 enum GRPC_ARG_SOCKET_FACTORY = "grpc.socket_factory"; 1644 } 1645 1646 1647 1648 1649 static if(!is(typeof(GRPC_ARG_SOCKET_MUTATOR))) { 1650 enum GRPC_ARG_SOCKET_MUTATOR = "grpc.socket_mutator"; 1651 } 1652 1653 1654 1655 1656 static if(!is(typeof(GRPC_ARG_LB_POLICY_NAME))) { 1657 enum GRPC_ARG_LB_POLICY_NAME = "grpc.lb_policy_name"; 1658 } 1659 static if(!is(typeof(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION))) { 1660 enum GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION = "grpc.service_config_disable_resolution"; 1661 } 1662 1663 1664 1665 1666 1667 1668 static if(!is(typeof(GRPC_ARG_SERVICE_CONFIG))) { 1669 enum GRPC_ARG_SERVICE_CONFIG = "grpc.service_config"; 1670 } 1671 1672 1673 1674 1675 static if(!is(typeof(GRPC_ARG_EXPAND_WILDCARD_ADDRS))) { 1676 enum GRPC_ARG_EXPAND_WILDCARD_ADDRS = "grpc.expand_wildcard_addrs"; 1677 } 1678 1679 1680 1681 1682 static if(!is(typeof(GRPC_ARG_RESOURCE_QUOTA))) { 1683 enum GRPC_ARG_RESOURCE_QUOTA = "grpc.resource_quota"; 1684 } 1685 1686 1687 1688 1689 static if(!is(typeof(GRPC_ARG_ALLOW_REUSEPORT))) { 1690 enum GRPC_ARG_ALLOW_REUSEPORT = "grpc.so_reuseport"; 1691 } 1692 1693 1694 1695 1696 static if(!is(typeof(GRPC_ARG_MAX_METADATA_SIZE))) { 1697 enum GRPC_ARG_MAX_METADATA_SIZE = "grpc.max_metadata_size"; 1698 } 1699 1700 1701 1702 1703 static if(!is(typeof(__ldiv_t_defined))) { 1704 enum __ldiv_t_defined = 1; 1705 } 1706 1707 1708 1709 1710 static if(!is(typeof(GRPC_ARG_TSI_MAX_FRAME_SIZE))) { 1711 enum GRPC_ARG_TSI_MAX_FRAME_SIZE = "grpc.tsi.max_frame_size"; 1712 } 1713 1714 1715 1716 1717 static if(!is(typeof(GRPC_SSL_SESSION_CACHE_ARG))) { 1718 enum GRPC_SSL_SESSION_CACHE_ARG = "grpc.ssl_session_cache"; 1719 } 1720 1721 1722 1723 1724 static if(!is(typeof(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG))) { 1725 enum GRPC_SSL_TARGET_NAME_OVERRIDE_ARG = "grpc.ssl_target_name_override"; 1726 } 1727 1728 1729 1730 1731 static if(!is(typeof(__lldiv_t_defined))) { 1732 enum __lldiv_t_defined = 1; 1733 } 1734 1735 1736 1737 1738 static if(!is(typeof(RAND_MAX))) { 1739 enum RAND_MAX = 2147483647; 1740 } 1741 1742 1743 1744 1745 static if(!is(typeof(EXIT_FAILURE))) { 1746 enum EXIT_FAILURE = 1; 1747 } 1748 1749 1750 1751 1752 static if(!is(typeof(EXIT_SUCCESS))) { 1753 enum EXIT_SUCCESS = 0; 1754 } 1755 1756 1757 1758 1759 1760 1761 static if(!is(typeof(GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS))) { 1762 enum GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS = "grpc.server_handshake_timeout_ms"; 1763 } 1764 1765 1766 1767 1768 static if(!is(typeof(GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS))) { 1769 enum GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS = "grpc.dns_min_time_between_resolutions_ms"; 1770 } 1771 1772 1773 1774 1775 static if(!is(typeof(GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS))) { 1776 enum GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS = "grpc.initial_reconnect_backoff_ms"; 1777 } 1778 1779 1780 1781 1782 static if(!is(typeof(GRPC_ARG_MAX_RECONNECT_BACKOFF_MS))) { 1783 enum GRPC_ARG_MAX_RECONNECT_BACKOFF_MS = "grpc.max_reconnect_backoff_ms"; 1784 } 1785 1786 1787 1788 1789 static if(!is(typeof(GRPC_ARG_MIN_RECONNECT_BACKOFF_MS))) { 1790 enum GRPC_ARG_MIN_RECONNECT_BACKOFF_MS = "grpc.min_reconnect_backoff_ms"; 1791 } 1792 1793 1794 1795 1796 static if(!is(typeof(GRPC_ARG_SECONDARY_USER_AGENT_STRING))) { 1797 enum GRPC_ARG_SECONDARY_USER_AGENT_STRING = "grpc.secondary_user_agent"; 1798 } 1799 1800 1801 1802 1803 static if(!is(typeof(GRPC_ARG_PRIMARY_USER_AGENT_STRING))) { 1804 enum GRPC_ARG_PRIMARY_USER_AGENT_STRING = "grpc.primary_user_agent"; 1805 } 1806 1807 1808 1809 1810 static if(!is(typeof(GRPC_ARG_DEFAULT_AUTHORITY))) { 1811 enum GRPC_ARG_DEFAULT_AUTHORITY = "grpc.default_authority"; 1812 } 1813 1814 1815 1816 1817 static if(!is(typeof(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS))) { 1818 enum GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS = "grpc.keepalive_permit_without_calls"; 1819 } 1820 1821 1822 1823 1824 static if(!is(typeof(GRPC_ARG_KEEPALIVE_TIMEOUT_MS))) { 1825 enum GRPC_ARG_KEEPALIVE_TIMEOUT_MS = "grpc.keepalive_timeout_ms"; 1826 } 1827 1828 1829 1830 1831 static if(!is(typeof(GRPC_ARG_KEEPALIVE_TIME_MS))) { 1832 enum GRPC_ARG_KEEPALIVE_TIME_MS = "grpc.keepalive_time_ms"; 1833 } 1834 1835 1836 1837 1838 static if(!is(typeof(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY))) { 1839 enum GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY = "grpc.http2.true_binary"; 1840 } 1841 1842 1843 1844 1845 static if(!is(typeof(GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE))) { 1846 enum GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE = "grpc.http2.write_buffer_size"; 1847 } 1848 1849 1850 1851 1852 static if(!is(typeof(GRPC_ARG_HTTP2_MAX_PING_STRIKES))) { 1853 enum GRPC_ARG_HTTP2_MAX_PING_STRIKES = "grpc.http2.max_ping_strikes"; 1854 } 1855 1856 1857 1858 1859 static if(!is(typeof(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA))) { 1860 enum GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA = "grpc.http2.max_pings_without_data"; 1861 } 1862 1863 1864 1865 1866 static if(!is(typeof(GRPC_ARG_HTTP2_SCHEME))) { 1867 enum GRPC_ARG_HTTP2_SCHEME = "grpc.http2_scheme"; 1868 } 1869 1870 1871 1872 1873 static if(!is(typeof(GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS))) { 1874 enum GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS = "grpc.http2.min_ping_interval_without_data_ms"; 1875 } 1876 1877 1878 1879 1880 static if(!is(typeof(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS))) { 1881 enum GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS = "grpc.http2.min_time_between_pings_ms"; 1882 } 1883 1884 1885 1886 1887 static if(!is(typeof(GRPC_ARG_HTTP2_BDP_PROBE))) { 1888 enum GRPC_ARG_HTTP2_BDP_PROBE = "grpc.http2.bdp_probe"; 1889 } 1890 1891 1892 1893 1894 static if(!is(typeof(GRPC_ARG_HTTP2_MAX_FRAME_SIZE))) { 1895 enum GRPC_ARG_HTTP2_MAX_FRAME_SIZE = "grpc.http2.max_frame_size"; 1896 } 1897 1898 1899 1900 1901 static if(!is(typeof(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER))) { 1902 enum GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER = "grpc.http2.hpack_table_size.encoder"; 1903 } 1904 1905 1906 1907 1908 static if(!is(typeof(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER))) { 1909 enum GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER = "grpc.http2.hpack_table_size.decoder"; 1910 } 1911 1912 1913 1914 1915 static if(!is(typeof(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES))) { 1916 enum GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES = "grpc.http2.lookahead_bytes"; 1917 } 1918 1919 1920 1921 1922 static if(!is(typeof(GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER))) { 1923 enum GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER = "grpc.http2.initial_sequence_number"; 1924 } 1925 1926 1927 1928 1929 static if(!is(typeof(GRPC_ARG_ENABLE_DEADLINE_CHECKS))) { 1930 enum GRPC_ARG_ENABLE_DEADLINE_CHECKS = "grpc.enable_deadline_checking"; 1931 } 1932 1933 1934 1935 1936 static if(!is(typeof(GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION))) { 1937 enum GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION = "grpc.per_message_compression"; 1938 } 1939 1940 1941 1942 1943 static if(!is(typeof(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS))) { 1944 enum GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS = "grpc.client_idle_timeout_ms"; 1945 } 1946 1947 1948 1949 1950 static if(!is(typeof(GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS))) { 1951 enum GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS = "grpc.max_connection_age_grace_ms"; 1952 } 1953 1954 1955 1956 1957 static if(!is(typeof(GRPC_ARG_MAX_CONNECTION_AGE_MS))) { 1958 enum GRPC_ARG_MAX_CONNECTION_AGE_MS = "grpc.max_connection_age_ms"; 1959 } 1960 1961 1962 1963 1964 static if(!is(typeof(GRPC_ARG_MAX_CONNECTION_IDLE_MS))) { 1965 enum GRPC_ARG_MAX_CONNECTION_IDLE_MS = "grpc.max_connection_idle_ms"; 1966 } 1967 1968 1969 1970 1971 static if(!is(typeof(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH))) { 1972 enum GRPC_ARG_MAX_SEND_MESSAGE_LENGTH = "grpc.max_send_message_length"; 1973 } 1974 1975 1976 1977 1978 1979 1980 static if(!is(typeof(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH))) { 1981 enum GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH = "grpc.max_receive_message_length"; 1982 } 1983 1984 1985 1986 1987 static if(!is(typeof(GRPC_ARG_MAX_CONCURRENT_STREAMS))) { 1988 enum GRPC_ARG_MAX_CONCURRENT_STREAMS = "grpc.max_concurrent_streams"; 1989 } 1990 1991 1992 1993 1994 static if(!is(typeof(GRPC_ARG_MINIMAL_STACK))) { 1995 enum GRPC_ARG_MINIMAL_STACK = "grpc.minimal_stack"; 1996 } 1997 1998 1999 2000 2001 static if(!is(typeof(GRPC_ARG_ENABLE_LOAD_REPORTING))) { 2002 enum GRPC_ARG_ENABLE_LOAD_REPORTING = "grpc.loadreporting"; 2003 } 2004 2005 2006 2007 2008 static if(!is(typeof(GRPC_ARG_ENABLE_CENSUS))) { 2009 enum GRPC_ARG_ENABLE_CENSUS = "grpc.census"; 2010 } 2011 static if(!is(typeof(GRPC_ALLOW_GPR_SLICE_FUNCTIONS))) { 2012 enum GRPC_ALLOW_GPR_SLICE_FUNCTIONS = 1; 2013 } 2014 static if(!is(typeof(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET))) { 2015 enum GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET = "grpc.compression_enabled_algorithms_bitset"; 2016 } 2017 2018 2019 2020 2021 static if(!is(typeof(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL))) { 2022 enum GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL = "grpc.default_compression_level"; 2023 } 2024 2025 2026 2027 2028 static if(!is(typeof(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM))) { 2029 enum GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM = "grpc.default_compression_algorithm"; 2030 } 2031 2032 2033 2034 2035 static if(!is(typeof(GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY))) { 2036 enum GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY = "grpc-internal-encoding-request"; 2037 } 2038 static if(!is(typeof(GRPC_GOOGLE_CREDENTIALS_ENV_VAR))) { 2039 enum GRPC_GOOGLE_CREDENTIALS_ENV_VAR = "GOOGLE_APPLICATION_CREDENTIALS"; 2040 } 2041 2042 2043 2044 2045 static if(!is(typeof(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR))) { 2046 enum GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR = "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"; 2047 } 2048 2049 2050 2051 2052 static if(!is(typeof(GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME))) { 2053 enum GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME = "security_level"; 2054 } 2055 2056 2057 2058 2059 static if(!is(typeof(GRPC_SSL_SESSION_REUSED_PROPERTY))) { 2060 enum GRPC_SSL_SESSION_REUSED_PROPERTY = "ssl_session_reused"; 2061 } 2062 2063 2064 2065 2066 static if(!is(typeof(GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME))) { 2067 enum GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME = "x509_pem_cert_chain"; 2068 } 2069 2070 2071 2072 2073 static if(!is(typeof(GRPC_X509_PEM_CERT_PROPERTY_NAME))) { 2074 enum GRPC_X509_PEM_CERT_PROPERTY_NAME = "x509_pem_cert"; 2075 } 2076 2077 2078 2079 2080 static if(!is(typeof(GRPC_X509_SAN_PROPERTY_NAME))) { 2081 enum GRPC_X509_SAN_PROPERTY_NAME = "x509_subject_alternative_name"; 2082 } 2083 2084 2085 2086 2087 static if(!is(typeof(GRPC_X509_CN_PROPERTY_NAME))) { 2088 enum GRPC_X509_CN_PROPERTY_NAME = "x509_common_name"; 2089 } 2090 2091 2092 2093 2094 static if(!is(typeof(GRPC_SSL_TRANSPORT_SECURITY_TYPE))) { 2095 enum GRPC_SSL_TRANSPORT_SECURITY_TYPE = "ssl"; 2096 } 2097 2098 2099 2100 2101 static if(!is(typeof(GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME))) { 2102 enum GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME = "transport_security_type"; 2103 } 2104 2105 2106 2107 2108 2109 2110 static if(!is(typeof(GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX))) { 2111 enum GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX = 4; 2112 } 2113 2114 2115 2116 2117 2118 2119 static if(!is(typeof(GRPC_MAX_COMPLETION_QUEUE_PLUCKERS))) { 2120 enum GRPC_MAX_COMPLETION_QUEUE_PLUCKERS = 6; 2121 } 2122 static if(!is(typeof(__GLIBC_MINOR__))) { 2123 enum __GLIBC_MINOR__ = 31; 2124 } 2125 2126 2127 2128 2129 static if(!is(typeof(__GLIBC__))) { 2130 enum __GLIBC__ = 2; 2131 } 2132 2133 2134 2135 2136 static if(!is(typeof(__GNU_LIBRARY__))) { 2137 enum __GNU_LIBRARY__ = 6; 2138 } 2139 2140 2141 2142 2143 static if(!is(typeof(__GLIBC_USE_DEPRECATED_SCANF))) { 2144 enum __GLIBC_USE_DEPRECATED_SCANF = 0; 2145 } 2146 2147 2148 2149 2150 static if(!is(typeof(__GLIBC_USE_DEPRECATED_GETS))) { 2151 enum __GLIBC_USE_DEPRECATED_GETS = 0; 2152 } 2153 2154 2155 2156 2157 static if(!is(typeof(__USE_FORTIFY_LEVEL))) { 2158 enum __USE_FORTIFY_LEVEL = 0; 2159 } 2160 2161 2162 2163 2164 static if(!is(typeof(__USE_GNU))) { 2165 enum __USE_GNU = 1; 2166 } 2167 2168 2169 2170 2171 static if(!is(typeof(__USE_ATFILE))) { 2172 enum __USE_ATFILE = 1; 2173 } 2174 2175 2176 2177 2178 static if(!is(typeof(__USE_MISC))) { 2179 enum __USE_MISC = 1; 2180 } 2181 2182 2183 2184 2185 static if(!is(typeof(__USE_LARGEFILE64))) { 2186 enum __USE_LARGEFILE64 = 1; 2187 } 2188 2189 2190 2191 2192 static if(!is(typeof(__USE_LARGEFILE))) { 2193 enum __USE_LARGEFILE = 1; 2194 } 2195 2196 2197 2198 2199 static if(!is(typeof(__USE_ISOC99))) { 2200 enum __USE_ISOC99 = 1; 2201 } 2202 2203 2204 2205 2206 static if(!is(typeof(__USE_ISOC95))) { 2207 enum __USE_ISOC95 = 1; 2208 } 2209 2210 2211 2212 2213 static if(!is(typeof(__USE_XOPEN2KXSI))) { 2214 enum __USE_XOPEN2KXSI = 1; 2215 } 2216 2217 2218 2219 2220 static if(!is(typeof(__USE_XOPEN2K))) { 2221 enum __USE_XOPEN2K = 1; 2222 } 2223 2224 2225 2226 2227 static if(!is(typeof(__USE_XOPEN2K8XSI))) { 2228 enum __USE_XOPEN2K8XSI = 1; 2229 } 2230 2231 2232 2233 2234 static if(!is(typeof(__USE_XOPEN2K8))) { 2235 enum __USE_XOPEN2K8 = 1; 2236 } 2237 2238 2239 2240 2241 static if(!is(typeof(_LARGEFILE_SOURCE))) { 2242 enum _LARGEFILE_SOURCE = 1; 2243 } 2244 2245 2246 2247 2248 static if(!is(typeof(__USE_UNIX98))) { 2249 enum __USE_UNIX98 = 1; 2250 } 2251 2252 2253 2254 2255 static if(!is(typeof(__USE_XOPEN_EXTENDED))) { 2256 enum __USE_XOPEN_EXTENDED = 1; 2257 } 2258 2259 2260 2261 2262 static if(!is(typeof(__USE_XOPEN))) { 2263 enum __USE_XOPEN = 1; 2264 } 2265 2266 2267 2268 2269 static if(!is(typeof(_ATFILE_SOURCE))) { 2270 enum _ATFILE_SOURCE = 1; 2271 } 2272 2273 2274 2275 2276 static if(!is(typeof(__USE_POSIX199506))) { 2277 enum __USE_POSIX199506 = 1; 2278 } 2279 2280 2281 2282 2283 static if(!is(typeof(__USE_POSIX199309))) { 2284 enum __USE_POSIX199309 = 1; 2285 } 2286 2287 2288 2289 2290 static if(!is(typeof(__USE_POSIX2))) { 2291 enum __USE_POSIX2 = 1; 2292 } 2293 2294 2295 2296 2297 static if(!is(typeof(__USE_POSIX))) { 2298 enum __USE_POSIX = 1; 2299 } 2300 2301 2302 2303 2304 static if(!is(typeof(_POSIX_C_SOURCE))) { 2305 enum _POSIX_C_SOURCE = 200809L; 2306 } 2307 2308 2309 2310 2311 static if(!is(typeof(_POSIX_SOURCE))) { 2312 enum _POSIX_SOURCE = 1; 2313 } 2314 2315 2316 2317 2318 static if(!is(typeof(__USE_ISOC11))) { 2319 enum __USE_ISOC11 = 1; 2320 } 2321 2322 2323 2324 2325 static if(!is(typeof(__GLIBC_USE_ISOC2X))) { 2326 enum __GLIBC_USE_ISOC2X = 1; 2327 } 2328 2329 2330 2331 2332 static if(!is(typeof(_LARGEFILE64_SOURCE))) { 2333 enum _LARGEFILE64_SOURCE = 1; 2334 } 2335 2336 2337 2338 2339 static if(!is(typeof(_XOPEN_SOURCE_EXTENDED))) { 2340 enum _XOPEN_SOURCE_EXTENDED = 1; 2341 } 2342 2343 2344 2345 2346 static if(!is(typeof(_XOPEN_SOURCE))) { 2347 enum _XOPEN_SOURCE = 700; 2348 } 2349 2350 2351 2352 2353 static if(!is(typeof(_ISOC2X_SOURCE))) { 2354 enum _ISOC2X_SOURCE = 1; 2355 } 2356 2357 2358 2359 2360 static if(!is(typeof(_ISOC11_SOURCE))) { 2361 enum _ISOC11_SOURCE = 1; 2362 } 2363 2364 2365 2366 2367 static if(!is(typeof(_ISOC99_SOURCE))) { 2368 enum _ISOC99_SOURCE = 1; 2369 } 2370 2371 2372 2373 2374 static if(!is(typeof(_ISOC95_SOURCE))) { 2375 enum _ISOC95_SOURCE = 1; 2376 } 2377 static if(!is(typeof(_FEATURES_H))) { 2378 enum _FEATURES_H = 1; 2379 } 2380 static if(!is(typeof(_ENDIAN_H))) { 2381 enum _ENDIAN_H = 1; 2382 } 2383 2384 2385 2386 2387 static if(!is(typeof(__SYSCALL_WORDSIZE))) { 2388 enum __SYSCALL_WORDSIZE = 64; 2389 } 2390 2391 2392 2393 2394 static if(!is(typeof(__WORDSIZE_TIME64_COMPAT32))) { 2395 enum __WORDSIZE_TIME64_COMPAT32 = 1; 2396 } 2397 2398 2399 2400 2401 static if(!is(typeof(__WORDSIZE))) { 2402 enum __WORDSIZE = 64; 2403 } 2404 static if(!is(typeof(_BITS_WCHAR_H))) { 2405 enum _BITS_WCHAR_H = 1; 2406 } 2407 2408 2409 2410 2411 static if(!is(typeof(__WCOREFLAG))) { 2412 enum __WCOREFLAG = 0x80; 2413 } 2414 2415 2416 2417 2418 static if(!is(typeof(__W_CONTINUED))) { 2419 enum __W_CONTINUED = 0xffff; 2420 } 2421 static if(!is(typeof(__WCLONE))) { 2422 enum __WCLONE = 0x80000000; 2423 } 2424 2425 2426 2427 2428 static if(!is(typeof(__WALL))) { 2429 enum __WALL = 0x40000000; 2430 } 2431 2432 2433 2434 2435 static if(!is(typeof(__WNOTHREAD))) { 2436 enum __WNOTHREAD = 0x20000000; 2437 } 2438 2439 2440 2441 2442 static if(!is(typeof(WNOWAIT))) { 2443 enum WNOWAIT = 0x01000000; 2444 } 2445 2446 2447 2448 2449 static if(!is(typeof(WCONTINUED))) { 2450 enum WCONTINUED = 8; 2451 } 2452 2453 2454 2455 2456 static if(!is(typeof(WEXITED))) { 2457 enum WEXITED = 4; 2458 } 2459 2460 2461 2462 2463 static if(!is(typeof(WSTOPPED))) { 2464 enum WSTOPPED = 2; 2465 } 2466 2467 2468 2469 2470 static if(!is(typeof(WUNTRACED))) { 2471 enum WUNTRACED = 2; 2472 } 2473 2474 2475 2476 2477 static if(!is(typeof(WNOHANG))) { 2478 enum WNOHANG = 1; 2479 } 2480 2481 2482 2483 2484 static if(!is(typeof(_BITS_UINTN_IDENTITY_H))) { 2485 enum _BITS_UINTN_IDENTITY_H = 1; 2486 } 2487 2488 2489 2490 2491 static if(!is(typeof(__FD_SETSIZE))) { 2492 enum __FD_SETSIZE = 1024; 2493 } 2494 2495 2496 2497 2498 static if(!is(typeof(__STATFS_MATCHES_STATFS64))) { 2499 enum __STATFS_MATCHES_STATFS64 = 1; 2500 } 2501 2502 2503 2504 2505 static if(!is(typeof(__RLIM_T_MATCHES_RLIM64_T))) { 2506 enum __RLIM_T_MATCHES_RLIM64_T = 1; 2507 } 2508 2509 2510 2511 2512 static if(!is(typeof(__INO_T_MATCHES_INO64_T))) { 2513 enum __INO_T_MATCHES_INO64_T = 1; 2514 } 2515 2516 2517 2518 2519 static if(!is(typeof(__OFF_T_MATCHES_OFF64_T))) { 2520 enum __OFF_T_MATCHES_OFF64_T = 1; 2521 } 2522 static if(!is(typeof(_BITS_TYPESIZES_H))) { 2523 enum _BITS_TYPESIZES_H = 1; 2524 } 2525 2526 2527 2528 2529 static if(!is(typeof(__timer_t_defined))) { 2530 enum __timer_t_defined = 1; 2531 } 2532 2533 2534 2535 2536 static if(!is(typeof(__time_t_defined))) { 2537 enum __time_t_defined = 1; 2538 } 2539 2540 2541 2542 2543 static if(!is(typeof(__struct_tm_defined))) { 2544 enum __struct_tm_defined = 1; 2545 } 2546 2547 2548 2549 2550 static if(!is(typeof(__timeval_defined))) { 2551 enum __timeval_defined = 1; 2552 } 2553 2554 2555 2556 2557 static if(!is(typeof(_STRUCT_TIMESPEC))) { 2558 enum _STRUCT_TIMESPEC = 1; 2559 } 2560 2561 2562 2563 2564 static if(!is(typeof(_BITS_TYPES_STRUCT_SCHED_PARAM))) { 2565 enum _BITS_TYPES_STRUCT_SCHED_PARAM = 1; 2566 } 2567 2568 2569 2570 2571 static if(!is(typeof(__itimerspec_defined))) { 2572 enum __itimerspec_defined = 1; 2573 } 2574 2575 2576 2577 2578 static if(!is(typeof(__sigset_t_defined))) { 2579 enum __sigset_t_defined = 1; 2580 } 2581 2582 2583 2584 2585 static if(!is(typeof(_BITS_TYPES_LOCALE_T_H))) { 2586 enum _BITS_TYPES_LOCALE_T_H = 1; 2587 } 2588 2589 2590 2591 2592 static if(!is(typeof(__clockid_t_defined))) { 2593 enum __clockid_t_defined = 1; 2594 } 2595 2596 2597 2598 2599 static if(!is(typeof(__clock_t_defined))) { 2600 enum __clock_t_defined = 1; 2601 } 2602 static if(!is(typeof(_BITS_TYPES___LOCALE_T_H))) { 2603 enum _BITS_TYPES___LOCALE_T_H = 1; 2604 } 2605 static if(!is(typeof(_BITS_TYPES_H))) { 2606 enum _BITS_TYPES_H = 1; 2607 } 2608 2609 2610 2611 2612 2613 2614 static if(!is(typeof(STA_CLK))) { 2615 enum STA_CLK = 0x8000; 2616 } 2617 2618 2619 2620 2621 static if(!is(typeof(STA_MODE))) { 2622 enum STA_MODE = 0x4000; 2623 } 2624 2625 2626 2627 2628 static if(!is(typeof(STA_NANO))) { 2629 enum STA_NANO = 0x2000; 2630 } 2631 2632 2633 2634 2635 static if(!is(typeof(STA_CLOCKERR))) { 2636 enum STA_CLOCKERR = 0x1000; 2637 } 2638 2639 2640 2641 2642 static if(!is(typeof(STA_PPSERROR))) { 2643 enum STA_PPSERROR = 0x0800; 2644 } 2645 2646 2647 2648 2649 static if(!is(typeof(STA_PPSWANDER))) { 2650 enum STA_PPSWANDER = 0x0400; 2651 } 2652 2653 2654 2655 2656 static if(!is(typeof(STA_PPSJITTER))) { 2657 enum STA_PPSJITTER = 0x0200; 2658 } 2659 2660 2661 2662 2663 static if(!is(typeof(STA_PPSSIGNAL))) { 2664 enum STA_PPSSIGNAL = 0x0100; 2665 } 2666 2667 2668 2669 2670 static if(!is(typeof(STA_FREQHOLD))) { 2671 enum STA_FREQHOLD = 0x0080; 2672 } 2673 2674 2675 2676 2677 static if(!is(typeof(STA_UNSYNC))) { 2678 enum STA_UNSYNC = 0x0040; 2679 } 2680 2681 2682 2683 2684 static if(!is(typeof(STA_DEL))) { 2685 enum STA_DEL = 0x0020; 2686 } 2687 2688 2689 2690 2691 static if(!is(typeof(STA_INS))) { 2692 enum STA_INS = 0x0010; 2693 } 2694 2695 2696 2697 2698 static if(!is(typeof(STA_FLL))) { 2699 enum STA_FLL = 0x0008; 2700 } 2701 2702 2703 2704 2705 static if(!is(typeof(STA_PPSTIME))) { 2706 enum STA_PPSTIME = 0x0004; 2707 } 2708 2709 2710 2711 2712 static if(!is(typeof(STA_PPSFREQ))) { 2713 enum STA_PPSFREQ = 0x0002; 2714 } 2715 2716 2717 2718 2719 static if(!is(typeof(STA_PLL))) { 2720 enum STA_PLL = 0x0001; 2721 } 2722 static if(!is(typeof(ADJ_OFFSET_SS_READ))) { 2723 enum ADJ_OFFSET_SS_READ = 0xa001; 2724 } 2725 2726 2727 2728 2729 static if(!is(typeof(ADJ_OFFSET_SINGLESHOT))) { 2730 enum ADJ_OFFSET_SINGLESHOT = 0x8001; 2731 } 2732 2733 2734 2735 2736 static if(!is(typeof(ADJ_TICK))) { 2737 enum ADJ_TICK = 0x4000; 2738 } 2739 2740 2741 2742 2743 static if(!is(typeof(ADJ_NANO))) { 2744 enum ADJ_NANO = 0x2000; 2745 } 2746 2747 2748 2749 2750 static if(!is(typeof(ADJ_MICRO))) { 2751 enum ADJ_MICRO = 0x1000; 2752 } 2753 2754 2755 2756 2757 static if(!is(typeof(ADJ_SETOFFSET))) { 2758 enum ADJ_SETOFFSET = 0x0100; 2759 } 2760 2761 2762 2763 2764 static if(!is(typeof(ADJ_TAI))) { 2765 enum ADJ_TAI = 0x0080; 2766 } 2767 2768 2769 2770 2771 static if(!is(typeof(ADJ_TIMECONST))) { 2772 enum ADJ_TIMECONST = 0x0020; 2773 } 2774 2775 2776 2777 2778 static if(!is(typeof(ADJ_STATUS))) { 2779 enum ADJ_STATUS = 0x0010; 2780 } 2781 2782 2783 2784 2785 static if(!is(typeof(ADJ_ESTERROR))) { 2786 enum ADJ_ESTERROR = 0x0008; 2787 } 2788 2789 2790 2791 2792 static if(!is(typeof(ADJ_MAXERROR))) { 2793 enum ADJ_MAXERROR = 0x0004; 2794 } 2795 2796 2797 2798 2799 static if(!is(typeof(ADJ_FREQUENCY))) { 2800 enum ADJ_FREQUENCY = 0x0002; 2801 } 2802 2803 2804 2805 2806 static if(!is(typeof(ADJ_OFFSET))) { 2807 enum ADJ_OFFSET = 0x0001; 2808 } 2809 2810 2811 2812 2813 static if(!is(typeof(_BITS_TIMEX_H))) { 2814 enum _BITS_TIMEX_H = 1; 2815 } 2816 static if(!is(typeof(_BITS_TIME64_H))) { 2817 enum _BITS_TIME64_H = 1; 2818 } 2819 2820 2821 2822 2823 static if(!is(typeof(TIMER_ABSTIME))) { 2824 enum TIMER_ABSTIME = 1; 2825 } 2826 2827 2828 2829 2830 static if(!is(typeof(CLOCK_TAI))) { 2831 enum CLOCK_TAI = 11; 2832 } 2833 2834 2835 2836 2837 static if(!is(typeof(CLOCK_BOOTTIME_ALARM))) { 2838 enum CLOCK_BOOTTIME_ALARM = 9; 2839 } 2840 2841 2842 2843 2844 static if(!is(typeof(CLOCK_REALTIME_ALARM))) { 2845 enum CLOCK_REALTIME_ALARM = 8; 2846 } 2847 2848 2849 2850 2851 static if(!is(typeof(CLOCK_BOOTTIME))) { 2852 enum CLOCK_BOOTTIME = 7; 2853 } 2854 2855 2856 2857 2858 static if(!is(typeof(CLOCK_MONOTONIC_COARSE))) { 2859 enum CLOCK_MONOTONIC_COARSE = 6; 2860 } 2861 2862 2863 2864 2865 static if(!is(typeof(CLOCK_REALTIME_COARSE))) { 2866 enum CLOCK_REALTIME_COARSE = 5; 2867 } 2868 2869 2870 2871 2872 static if(!is(typeof(CLOCK_MONOTONIC_RAW))) { 2873 enum CLOCK_MONOTONIC_RAW = 4; 2874 } 2875 2876 2877 2878 2879 static if(!is(typeof(CLOCK_THREAD_CPUTIME_ID))) { 2880 enum CLOCK_THREAD_CPUTIME_ID = 3; 2881 } 2882 2883 2884 2885 2886 static if(!is(typeof(CLOCK_PROCESS_CPUTIME_ID))) { 2887 enum CLOCK_PROCESS_CPUTIME_ID = 2; 2888 } 2889 2890 2891 2892 2893 static if(!is(typeof(CLOCK_MONOTONIC))) { 2894 enum CLOCK_MONOTONIC = 1; 2895 } 2896 2897 2898 2899 2900 static if(!is(typeof(CLOCK_REALTIME))) { 2901 enum CLOCK_REALTIME = 0; 2902 } 2903 2904 2905 2906 2907 2908 2909 static if(!is(typeof(_BITS_TIME_H))) { 2910 enum _BITS_TIME_H = 1; 2911 } 2912 2913 2914 2915 2916 static if(!is(typeof(_THREAD_SHARED_TYPES_H))) { 2917 enum _THREAD_SHARED_TYPES_H = 1; 2918 } 2919 static if(!is(typeof(__PTHREAD_MUTEX_HAVE_PREV))) { 2920 enum __PTHREAD_MUTEX_HAVE_PREV = 1; 2921 } 2922 2923 2924 2925 2926 static if(!is(typeof(_THREAD_MUTEX_INTERNAL_H))) { 2927 enum _THREAD_MUTEX_INTERNAL_H = 1; 2928 } 2929 2930 2931 2932 2933 static if(!is(typeof(_BITS_STDINT_UINTN_H))) { 2934 enum _BITS_STDINT_UINTN_H = 1; 2935 } 2936 2937 2938 2939 2940 static if(!is(typeof(_BITS_STDINT_INTN_H))) { 2941 enum _BITS_STDINT_INTN_H = 1; 2942 } 2943 2944 2945 2946 2947 static if(!is(typeof(_BITS_SETJMP_H))) { 2948 enum _BITS_SETJMP_H = 1; 2949 } 2950 static if(!is(typeof(__FD_ZERO_STOS))) { 2951 enum __FD_ZERO_STOS = "stosq"; 2952 } 2953 2954 2955 2956 2957 static if(!is(typeof(CLONE_IO))) { 2958 enum CLONE_IO = 0x80000000; 2959 } 2960 2961 2962 2963 2964 static if(!is(typeof(CLONE_NEWNET))) { 2965 enum CLONE_NEWNET = 0x40000000; 2966 } 2967 2968 2969 2970 2971 static if(!is(typeof(CLONE_NEWPID))) { 2972 enum CLONE_NEWPID = 0x20000000; 2973 } 2974 2975 2976 2977 2978 static if(!is(typeof(CLONE_NEWUSER))) { 2979 enum CLONE_NEWUSER = 0x10000000; 2980 } 2981 2982 2983 2984 2985 static if(!is(typeof(CLONE_NEWIPC))) { 2986 enum CLONE_NEWIPC = 0x08000000; 2987 } 2988 2989 2990 2991 2992 static if(!is(typeof(CLONE_NEWUTS))) { 2993 enum CLONE_NEWUTS = 0x04000000; 2994 } 2995 2996 2997 2998 2999 static if(!is(typeof(CLONE_NEWCGROUP))) { 3000 enum CLONE_NEWCGROUP = 0x02000000; 3001 } 3002 3003 3004 3005 3006 static if(!is(typeof(CLONE_CHILD_SETTID))) { 3007 enum CLONE_CHILD_SETTID = 0x01000000; 3008 } 3009 3010 3011 3012 3013 static if(!is(typeof(CLONE_UNTRACED))) { 3014 enum CLONE_UNTRACED = 0x00800000; 3015 } 3016 3017 3018 3019 3020 static if(!is(typeof(CLONE_DETACHED))) { 3021 enum CLONE_DETACHED = 0x00400000; 3022 } 3023 3024 3025 3026 3027 static if(!is(typeof(CLONE_CHILD_CLEARTID))) { 3028 enum CLONE_CHILD_CLEARTID = 0x00200000; 3029 } 3030 3031 3032 3033 3034 static if(!is(typeof(CLONE_PARENT_SETTID))) { 3035 enum CLONE_PARENT_SETTID = 0x00100000; 3036 } 3037 3038 3039 3040 3041 static if(!is(typeof(CLONE_SETTLS))) { 3042 enum CLONE_SETTLS = 0x00080000; 3043 } 3044 3045 3046 3047 3048 static if(!is(typeof(CLONE_SYSVSEM))) { 3049 enum CLONE_SYSVSEM = 0x00040000; 3050 } 3051 3052 3053 3054 3055 static if(!is(typeof(CLONE_NEWNS))) { 3056 enum CLONE_NEWNS = 0x00020000; 3057 } 3058 3059 3060 3061 3062 3063 3064 static if(!is(typeof(CLONE_THREAD))) { 3065 enum CLONE_THREAD = 0x00010000; 3066 } 3067 3068 3069 3070 3071 static if(!is(typeof(CLONE_PARENT))) { 3072 enum CLONE_PARENT = 0x00008000; 3073 } 3074 3075 3076 3077 3078 static if(!is(typeof(CLONE_VFORK))) { 3079 enum CLONE_VFORK = 0x00004000; 3080 } 3081 3082 3083 3084 3085 static if(!is(typeof(CLONE_PTRACE))) { 3086 enum CLONE_PTRACE = 0x00002000; 3087 } 3088 3089 3090 3091 3092 static if(!is(typeof(CLONE_PIDFD))) { 3093 enum CLONE_PIDFD = 0x00001000; 3094 } 3095 3096 3097 3098 3099 static if(!is(typeof(CLONE_SIGHAND))) { 3100 enum CLONE_SIGHAND = 0x00000800; 3101 } 3102 3103 3104 3105 3106 static if(!is(typeof(CLONE_FILES))) { 3107 enum CLONE_FILES = 0x00000400; 3108 } 3109 3110 3111 3112 3113 static if(!is(typeof(CLONE_FS))) { 3114 enum CLONE_FS = 0x00000200; 3115 } 3116 3117 3118 3119 3120 static if(!is(typeof(CLONE_VM))) { 3121 enum CLONE_VM = 0x00000100; 3122 } 3123 3124 3125 3126 3127 static if(!is(typeof(CSIGNAL))) { 3128 enum CSIGNAL = 0x000000ff; 3129 } 3130 3131 3132 3133 3134 static if(!is(typeof(SCHED_RESET_ON_FORK))) { 3135 enum SCHED_RESET_ON_FORK = 0x40000000; 3136 } 3137 3138 3139 3140 3141 static if(!is(typeof(SCHED_DEADLINE))) { 3142 enum SCHED_DEADLINE = 6; 3143 } 3144 3145 3146 3147 3148 static if(!is(typeof(SCHED_IDLE))) { 3149 enum SCHED_IDLE = 5; 3150 } 3151 3152 3153 3154 3155 static if(!is(typeof(SCHED_ISO))) { 3156 enum SCHED_ISO = 4; 3157 } 3158 3159 3160 3161 3162 static if(!is(typeof(SCHED_BATCH))) { 3163 enum SCHED_BATCH = 3; 3164 } 3165 3166 3167 3168 3169 static if(!is(typeof(SCHED_RR))) { 3170 enum SCHED_RR = 2; 3171 } 3172 3173 3174 3175 3176 static if(!is(typeof(SCHED_FIFO))) { 3177 enum SCHED_FIFO = 1; 3178 } 3179 3180 3181 3182 3183 static if(!is(typeof(SCHED_OTHER))) { 3184 enum SCHED_OTHER = 0; 3185 } 3186 3187 3188 3189 3190 static if(!is(typeof(_BITS_SCHED_H))) { 3191 enum _BITS_SCHED_H = 1; 3192 } 3193 3194 3195 3196 3197 static if(!is(typeof(__have_pthread_attr_t))) { 3198 enum __have_pthread_attr_t = 1; 3199 } 3200 3201 3202 3203 3204 static if(!is(typeof(_BITS_PTHREADTYPES_COMMON_H))) { 3205 enum _BITS_PTHREADTYPES_COMMON_H = 1; 3206 } 3207 static if(!is(typeof(__SIZEOF_PTHREAD_BARRIERATTR_T))) { 3208 enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; 3209 } 3210 3211 3212 3213 3214 static if(!is(typeof(__SIZEOF_PTHREAD_RWLOCKATTR_T))) { 3215 enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; 3216 } 3217 3218 3219 3220 3221 static if(!is(typeof(__SIZEOF_PTHREAD_CONDATTR_T))) { 3222 enum __SIZEOF_PTHREAD_CONDATTR_T = 4; 3223 } 3224 3225 3226 3227 3228 static if(!is(typeof(__SIZEOF_PTHREAD_COND_T))) { 3229 enum __SIZEOF_PTHREAD_COND_T = 48; 3230 } 3231 3232 3233 3234 3235 static if(!is(typeof(__SIZEOF_PTHREAD_MUTEXATTR_T))) { 3236 enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; 3237 } 3238 3239 3240 3241 3242 static if(!is(typeof(__SIZEOF_PTHREAD_BARRIER_T))) { 3243 enum __SIZEOF_PTHREAD_BARRIER_T = 32; 3244 } 3245 3246 3247 3248 3249 static if(!is(typeof(__SIZEOF_PTHREAD_RWLOCK_T))) { 3250 enum __SIZEOF_PTHREAD_RWLOCK_T = 56; 3251 } 3252 3253 3254 3255 3256 static if(!is(typeof(__SIZEOF_PTHREAD_ATTR_T))) { 3257 enum __SIZEOF_PTHREAD_ATTR_T = 56; 3258 } 3259 3260 3261 3262 3263 static if(!is(typeof(__SIZEOF_PTHREAD_MUTEX_T))) { 3264 enum __SIZEOF_PTHREAD_MUTEX_T = 40; 3265 } 3266 3267 3268 3269 3270 static if(!is(typeof(_BITS_PTHREADTYPES_ARCH_H))) { 3271 enum _BITS_PTHREADTYPES_ARCH_H = 1; 3272 } 3273 3274 3275 3276 3277 static if(!is(typeof(__LONG_DOUBLE_USES_FLOAT128))) { 3278 enum __LONG_DOUBLE_USES_FLOAT128 = 0; 3279 } 3280 3281 3282 3283 3284 static if(!is(typeof(__GLIBC_USE_IEC_60559_TYPES_EXT))) { 3285 enum __GLIBC_USE_IEC_60559_TYPES_EXT = 1; 3286 } 3287 3288 3289 3290 3291 static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT_C2X))) { 3292 enum __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = 1; 3293 } 3294 3295 3296 3297 3298 static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT))) { 3299 enum __GLIBC_USE_IEC_60559_FUNCS_EXT = 1; 3300 } 3301 3302 3303 3304 3305 static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT_C2X))) { 3306 enum __GLIBC_USE_IEC_60559_BFP_EXT_C2X = 1; 3307 } 3308 3309 3310 3311 3312 static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT))) { 3313 enum __GLIBC_USE_IEC_60559_BFP_EXT = 1; 3314 } 3315 3316 3317 3318 3319 static if(!is(typeof(__GLIBC_USE_LIB_EXT2))) { 3320 enum __GLIBC_USE_LIB_EXT2 = 1; 3321 } 3322 3323 3324 3325 3326 static if(!is(typeof(__HAVE_FLOAT64X_LONG_DOUBLE))) { 3327 enum __HAVE_FLOAT64X_LONG_DOUBLE = 1; 3328 } 3329 3330 3331 3332 3333 static if(!is(typeof(__HAVE_FLOAT64X))) { 3334 enum __HAVE_FLOAT64X = 1; 3335 } 3336 3337 3338 3339 3340 static if(!is(typeof(__HAVE_DISTINCT_FLOAT128))) { 3341 enum __HAVE_DISTINCT_FLOAT128 = 0; 3342 } 3343 3344 3345 3346 3347 static if(!is(typeof(__HAVE_FLOAT128))) { 3348 enum __HAVE_FLOAT128 = 0; 3349 } 3350 static if(!is(typeof(__HAVE_FLOATN_NOT_TYPEDEF))) { 3351 enum __HAVE_FLOATN_NOT_TYPEDEF = 0; 3352 } 3353 static if(!is(typeof(__HAVE_DISTINCT_FLOAT64X))) { 3354 enum __HAVE_DISTINCT_FLOAT64X = 0; 3355 } 3356 3357 3358 3359 3360 static if(!is(typeof(__HAVE_DISTINCT_FLOAT32X))) { 3361 enum __HAVE_DISTINCT_FLOAT32X = 0; 3362 } 3363 3364 3365 3366 3367 static if(!is(typeof(__HAVE_DISTINCT_FLOAT64))) { 3368 enum __HAVE_DISTINCT_FLOAT64 = 0; 3369 } 3370 3371 3372 3373 3374 static if(!is(typeof(__HAVE_DISTINCT_FLOAT32))) { 3375 enum __HAVE_DISTINCT_FLOAT32 = 0; 3376 } 3377 3378 3379 3380 3381 3382 3383 static if(!is(typeof(__HAVE_FLOAT128X))) { 3384 enum __HAVE_FLOAT128X = 0; 3385 } 3386 3387 3388 3389 3390 static if(!is(typeof(__HAVE_FLOAT32X))) { 3391 enum __HAVE_FLOAT32X = 1; 3392 } 3393 3394 3395 3396 3397 static if(!is(typeof(__HAVE_FLOAT64))) { 3398 enum __HAVE_FLOAT64 = 1; 3399 } 3400 3401 3402 3403 3404 static if(!is(typeof(__HAVE_FLOAT32))) { 3405 enum __HAVE_FLOAT32 = 1; 3406 } 3407 3408 3409 3410 3411 static if(!is(typeof(__HAVE_FLOAT16))) { 3412 enum __HAVE_FLOAT16 = 0; 3413 } 3414 static if(!is(typeof(_BITS_ENDIANNESS_H))) { 3415 enum _BITS_ENDIANNESS_H = 1; 3416 } 3417 static if(!is(typeof(__PDP_ENDIAN))) { 3418 enum __PDP_ENDIAN = 3412; 3419 } 3420 3421 3422 3423 3424 static if(!is(typeof(__BIG_ENDIAN))) { 3425 enum __BIG_ENDIAN = 4321; 3426 } 3427 3428 3429 3430 3431 static if(!is(typeof(__LITTLE_ENDIAN))) { 3432 enum __LITTLE_ENDIAN = 1234; 3433 } 3434 3435 3436 3437 3438 static if(!is(typeof(_BITS_ENDIAN_H))) { 3439 enum _BITS_ENDIAN_H = 1; 3440 } 3441 static if(!is(typeof(__CPU_SETSIZE))) { 3442 enum __CPU_SETSIZE = 1024; 3443 } 3444 3445 3446 3447 3448 static if(!is(typeof(_BITS_CPU_SET_H))) { 3449 enum _BITS_CPU_SET_H = 1; 3450 } 3451 static if(!is(typeof(_BITS_BYTESWAP_H))) { 3452 enum _BITS_BYTESWAP_H = 1; 3453 } 3454 3455 3456 3457 3458 3459 3460 static if(!is(typeof(_ALLOCA_H))) { 3461 enum _ALLOCA_H = 1; 3462 } 3463 3464 3465 3466 3467 static if(!is(typeof(_SYS_CDEFS_H))) { 3468 enum _SYS_CDEFS_H = 1; 3469 } 3470 static if(!is(typeof(__glibc_c99_flexarr_available))) { 3471 enum __glibc_c99_flexarr_available = 1; 3472 } 3473 static if(!is(typeof(__HAVE_GENERIC_SELECTION))) { 3474 enum __HAVE_GENERIC_SELECTION = 1; 3475 } 3476 3477 3478 3479 3480 static if(!is(typeof(_SYS_SELECT_H))) { 3481 enum _SYS_SELECT_H = 1; 3482 } 3483 static if(!is(typeof(_SYS_TYPES_H))) { 3484 enum _SYS_TYPES_H = 1; 3485 } 3486 static if(!is(typeof(__BIT_TYPES_DEFINED__))) { 3487 enum __BIT_TYPES_DEFINED__ = 1; 3488 } 3489 static if(!is(typeof(_TIME_H))) { 3490 enum _TIME_H = 1; 3491 } 3492 3493 3494 3495 3496 static if(!is(typeof(TIME_UTC))) { 3497 enum TIME_UTC = 1; 3498 } 3499 static if(!is(typeof(__GNUC_VA_LIST))) { 3500 enum __GNUC_VA_LIST = 1; 3501 } 3502 }