| /* |
| * |
| * Copyright 2015, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #include <ruby/ruby.h> |
| |
| #include "rb_compression_options.h" |
| #include "rb_grpc_imports.generated.h" |
| |
| #include <grpc/compression.h> |
| #include <grpc/grpc.h> |
| #include <grpc/impl/codegen/alloc.h> |
| #include <grpc/impl/codegen/compression_types.h> |
| #include <grpc/impl/codegen/grpc_types.h> |
| #include <string.h> |
| |
| #include "rb_grpc.h" |
| |
| static VALUE grpc_rb_cCompressionOptions = Qnil; |
| |
| /* grpc_rb_compression_options wraps a grpc_compression_options. |
| * It can be used to get the channel argument key-values for specific |
| * compression settings. */ |
| |
| /* Note that ruby objects of this type don't carry any state in other |
| * Ruby objects and don't have a mark for GC. */ |
| typedef struct grpc_rb_compression_options { |
| /* The actual compression options that's being wrapped */ |
| grpc_compression_options *wrapped; |
| } grpc_rb_compression_options; |
| |
| /* Destroys the compression options instances and free the |
| * wrapped grpc compression options. */ |
| static void grpc_rb_compression_options_free(void *p) { |
| grpc_rb_compression_options *wrapper = NULL; |
| if (p == NULL) { |
| return; |
| }; |
| wrapper = (grpc_rb_compression_options *)p; |
| |
| if (wrapper->wrapped != NULL) { |
| gpr_free(wrapper->wrapped); |
| wrapper->wrapped = NULL; |
| } |
| |
| xfree(p); |
| } |
| |
| /* Ruby recognized data type for the CompressionOptions class. */ |
| static rb_data_type_t grpc_rb_compression_options_data_type = { |
| "grpc_compression_options", |
| {NULL, |
| grpc_rb_compression_options_free, |
| GRPC_RB_MEMSIZE_UNAVAILABLE, |
| {NULL, NULL}}, |
| NULL, |
| NULL, |
| #ifdef RUBY_TYPED_FREE_IMMEDIATELY |
| RUBY_TYPED_FREE_IMMEDIATELY |
| #endif |
| }; |
| |
| /* Allocates CompressionOptions instances. |
| Allocate the wrapped grpc compression options and |
| initialize it here too. */ |
| static VALUE grpc_rb_compression_options_alloc(VALUE cls) { |
| grpc_rb_compression_options *wrapper = |
| gpr_malloc(sizeof(grpc_rb_compression_options)); |
| wrapper->wrapped = NULL; |
| wrapper->wrapped = gpr_malloc(sizeof(grpc_compression_options)); |
| grpc_compression_options_init(wrapper->wrapped); |
| |
| return TypedData_Wrap_Struct(cls, &grpc_rb_compression_options_data_type, |
| wrapper); |
| } |
| |
| /* Disables a compression algorithm, given the GRPC core internal number of a |
| * compression algorithm. */ |
| VALUE grpc_rb_compression_options_disable_compression_algorithm_internal( |
| VALUE self, VALUE algorithm_to_disable) { |
| grpc_compression_algorithm compression_algorithm = 0; |
| grpc_rb_compression_options *wrapper = NULL; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| compression_algorithm = |
| (grpc_compression_algorithm)NUM2INT(algorithm_to_disable); |
| |
| grpc_compression_options_disable_algorithm(wrapper->wrapped, |
| compression_algorithm); |
| |
| return Qnil; |
| } |
| |
| /* Provides a bitset as a ruby number that is suitable to pass to |
| * the GRPC core as a channel argument to enable compression algorithms. */ |
| /* Gets the compression internal enum value of a compression level given its |
| * name. */ |
| grpc_compression_level grpc_rb_compression_options_level_name_to_value_internal( |
| VALUE level_name) { |
| VALUE none_symbol = Qnil; |
| VALUE low_symbol = Qnil; |
| VALUE medium_symbol = Qnil; |
| VALUE high_symbol = Qnil; |
| |
| Check_Type(level_name, T_SYMBOL); |
| |
| /* Ruby symbols that correspond to names of valid compression levels */ |
| none_symbol = |
| rb_const_get(grpc_rb_cCompressionOptions, rb_intern("COMPRESS_NONE_SYM")); |
| low_symbol = |
| rb_const_get(grpc_rb_cCompressionOptions, rb_intern("COMPRESS_LOW_SYM")); |
| medium_symbol = rb_const_get(grpc_rb_cCompressionOptions, |
| rb_intern("COMPRESS_MEDIUM_SYM")); |
| high_symbol = |
| rb_const_get(grpc_rb_cCompressionOptions, rb_intern("COMPRESS_HIGH_SYM")); |
| |
| /* Check the compression level of the name passed in, and see which macro |
| * from the GRPC core header files match. */ |
| if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, none_symbol)) != 0) { |
| return GRPC_COMPRESS_LEVEL_NONE; |
| } else if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, low_symbol)) != |
| 0) { |
| return GRPC_COMPRESS_LEVEL_LOW; |
| } else if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, medium_symbol)) != |
| 0) { |
| return GRPC_COMPRESS_LEVEL_MED; |
| } else if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, high_symbol)) != |
| 0) { |
| return GRPC_COMPRESS_LEVEL_HIGH; |
| } else { |
| rb_raise(rb_eArgError, |
| "Unrecognized compression level name." |
| "Valid compression level names are none, low, medium, and high."); |
| } |
| } |
| |
| /* Wrapper over grpc_rb_compression_options_level_name_to_value available for |
| * use or testing. |
| * Raises an exception for unrecognized level names. */ |
| VALUE grpc_rb_compression_options_level_name_to_value(VALUE self, |
| VALUE level_name) { |
| return INT2NUM((int)grpc_rb_compression_options_level_name_to_value_internal( |
| level_name)); |
| } |
| |
| /* Sets the default compression level, given the name of a compression level. |
| * Throws an error if no algorithm matched. */ |
| void grpc_rb_compression_options_set_default_level( |
| grpc_compression_options *options, VALUE new_level_name) { |
| options->default_level.level = |
| grpc_rb_compression_options_level_name_to_value_internal(new_level_name); |
| options->default_level.is_set = 1; |
| } |
| |
| /* Gets the internal value of a compression algorithm suitable as the value |
| * in a GRPC core channel arguments hash. |
| * algorithm_value is an out parameter. |
| * Raises an error if the name of the algorithm passed in is invalid. */ |
| void grpc_rb_compression_options_algorithm_name_to_value_internal( |
| grpc_compression_algorithm *algorithm_value, VALUE algorithm_name) { |
| char *name_str = NULL; |
| long name_len = 0; |
| VALUE algorithm_name_as_string = Qnil; |
| |
| Check_Type(algorithm_name, T_SYMBOL); |
| |
| /* Convert the algorithm symbol to a ruby string, so that we can get the |
| * correct C string out of it. */ |
| algorithm_name_as_string = rb_funcall(algorithm_name, rb_intern("to_s"), 0); |
| |
| name_str = RSTRING_PTR(algorithm_name_as_string); |
| name_len = RSTRING_LEN(algorithm_name_as_string); |
| |
| /* Raise an error if the name isn't recognized as a compression algorithm by |
| * the algorithm parse function |
| * in GRPC core. */ |
| if (!grpc_compression_algorithm_parse(name_str, name_len, algorithm_value)) { |
| rb_raise(rb_eNameError, "Invalid compression algorithm name: %s", |
| StringValueCStr(algorithm_name_as_string)); |
| } |
| } |
| |
| /* Wrapper around algorithm_name_to_value_internal function available for use or |
| * testing. */ |
| VALUE grpc_rb_compression_options_algorithm_name_to_value( |
| VALUE self, VALUE algorithm_name) { |
| grpc_compression_algorithm algorithm_value; |
| grpc_rb_compression_options_algorithm_name_to_value_internal(&algorithm_value, |
| algorithm_name); |
| |
| return INT2NUM((int)algorithm_value); |
| } |
| |
| /* Indicates whether a given algorithm is enabled on this instance, given the |
| * readable algorithm name. */ |
| VALUE grpc_rb_compression_options_is_algorithm_enabled(VALUE self, |
| VALUE algorithm_name) { |
| grpc_rb_compression_options *wrapper = NULL; |
| grpc_compression_algorithm internal_algorithm_value; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| grpc_rb_compression_options_algorithm_name_to_value_internal( |
| &internal_algorithm_value, algorithm_name); |
| |
| if (grpc_compression_options_is_algorithm_enabled(wrapper->wrapped, |
| internal_algorithm_value)) { |
| return Qtrue; |
| } |
| return Qfalse; |
| } |
| |
| /* Sets the default algorithm to the name of the algorithm passed in. |
| * Raises an error if the name is not a valid compression algorithm name. */ |
| void grpc_rb_compression_options_set_default_algorithm( |
| grpc_compression_options *options, VALUE algorithm_name) { |
| grpc_rb_compression_options_algorithm_name_to_value_internal( |
| &options->default_algorithm.algorithm, algorithm_name); |
| options->default_algorithm.is_set = 1; |
| } |
| |
| /* Disables an algorithm on the current instance, given the name of an |
| * algorithm. |
| * Fails if the algorithm name is invalid. */ |
| void grpc_rb_compression_options_disable_algorithm( |
| grpc_compression_options *compression_options, VALUE algorithm_name) { |
| grpc_compression_algorithm internal_algorithm_value; |
| |
| grpc_rb_compression_options_algorithm_name_to_value_internal( |
| &internal_algorithm_value, algorithm_name); |
| grpc_compression_options_disable_algorithm(compression_options, |
| internal_algorithm_value); |
| } |
| |
| /* Provides a ruby hash of GRPC core channel argument key-values that |
| * correspond to the compression settings on this instance. */ |
| VALUE grpc_rb_compression_options_to_hash(VALUE self) { |
| grpc_rb_compression_options *wrapper = NULL; |
| grpc_compression_options *compression_options = NULL; |
| VALUE channel_arg_hash = rb_hash_new(); |
| VALUE key = Qnil; |
| VALUE value = Qnil; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| compression_options = wrapper->wrapped; |
| |
| /* Add key-value pairs to the new Ruby hash. It can be used |
| * as GRPC core channel arguments. */ |
| if (compression_options->default_level.is_set) { |
| key = rb_str_new2(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL); |
| value = INT2NUM((int)compression_options->default_level.level); |
| rb_hash_aset(channel_arg_hash, key, value); |
| } |
| |
| if (compression_options->default_algorithm.is_set) { |
| key = rb_str_new2(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM); |
| value = INT2NUM((int)compression_options->default_algorithm.algorithm); |
| rb_hash_aset(channel_arg_hash, key, value); |
| } |
| |
| key = rb_str_new2(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET); |
| value = INT2NUM((int)compression_options->enabled_algorithms_bitset); |
| rb_hash_aset(channel_arg_hash, key, value); |
| |
| return channel_arg_hash; |
| } |
| |
| /* Converts an internal enum level value to a readable level name. |
| * Fails if the level value is invalid. */ |
| VALUE grpc_rb_compression_options_level_value_to_name_internal( |
| grpc_compression_level compression_value) { |
| switch (compression_value) { |
| case GRPC_COMPRESS_LEVEL_NONE: |
| return rb_const_get(grpc_rb_cCompressionOptions, |
| rb_intern("COMPRESS_NONE_SYM")); |
| case GRPC_COMPRESS_LEVEL_LOW: |
| return rb_const_get(grpc_rb_cCompressionOptions, |
| rb_intern("COMPRESS_LOW_SYM")); |
| case GRPC_COMPRESS_LEVEL_MED: |
| return rb_const_get(grpc_rb_cCompressionOptions, |
| rb_intern("COMPRESS_MEDIUM_SYM")); |
| case GRPC_COMPRESS_LEVEL_HIGH: |
| return rb_const_get(grpc_rb_cCompressionOptions, |
| rb_intern("COMPRESS_HIGH_SYM")); |
| default: |
| rb_raise( |
| rb_eArgError, |
| "Failed to convert compression level value to name for value: %d", |
| (int)compression_value); |
| } |
| } |
| |
| /* Wrapper of internal method that makes it available for use and testing. */ |
| VALUE grpc_rb_compression_options_level_value_to_name(VALUE self, |
| VALUE compression_value) { |
| Check_Type(compression_value, T_FIXNUM); |
| return grpc_rb_compression_options_level_value_to_name_internal( |
| (grpc_compression_level)NUM2INT(compression_value)); |
| } |
| |
| /* Converts an algorithm internal enum value to a readable name. |
| * Fails if the enum value is invalid. */ |
| VALUE grpc_rb_compression_options_algorithm_value_to_name_internal( |
| grpc_compression_algorithm internal_value) { |
| char *algorithm_name = NULL; |
| |
| if (!grpc_compression_algorithm_name(internal_value, &algorithm_name)) { |
| rb_raise(rb_eArgError, "Failed to convert algorithm value to name"); |
| } |
| |
| return ID2SYM(rb_intern(algorithm_name)); |
| } |
| |
| /* Wrapper of algorithm_to_name internal function available for ues and testing. |
| */ |
| VALUE grpc_rb_compression_options_algorithm_value_to_name( |
| VALUE self, VALUE algorithm_value) { |
| grpc_compression_algorithm algorithm_internal_value; |
| algorithm_internal_value = |
| (grpc_compression_algorithm)NUM2INT(algorithm_value); |
| |
| return grpc_rb_compression_options_algorithm_value_to_name_internal( |
| algorithm_internal_value); |
| } |
| |
| /* Gets the internal value of the default compression level that is to be passed |
| * to the GRPC core as a channel argument value. |
| * A nil return value means that it hasn't been set. */ |
| VALUE grpc_rb_compression_options_get_default_algorithm_internal_value( |
| VALUE self) { |
| grpc_rb_compression_options *wrapper = NULL; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| |
| if (wrapper->wrapped->default_algorithm.is_set) { |
| return INT2NUM(wrapper->wrapped->default_algorithm.algorithm); |
| } |
| return Qnil; |
| } |
| |
| /* Gets the readable name of the default algorithm if one has been set. |
| * Returns nil if no algorithm has been set. */ |
| VALUE grpc_rb_compression_options_get_default_algorithm(VALUE self) { |
| VALUE algorithm_value = |
| grpc_rb_compression_options_get_default_algorithm_internal_value(self); |
| |
| if (RTEST(algorithm_value)) { |
| return grpc_rb_compression_options_algorithm_value_to_name(self, |
| algorithm_value); |
| } |
| |
| return Qnil; |
| } |
| |
| /* Gets the internal enum value of the default algorithm if one has been set. |
| * Returns nil if no default algorithm has been set. */ |
| VALUE grpc_rb_compression_options_get_default_level_internal_value(VALUE self) { |
| grpc_rb_compression_options *wrapper = NULL; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| |
| if (wrapper->wrapped->default_level.is_set) { |
| return INT2NUM((int)wrapper->wrapped->default_level.level); |
| } |
| return Qnil; |
| } |
| |
| /* Gets the internal value of the default compression level that is to be passed |
| * to the GRPC core as a channel argument value. |
| * A nil return value means that it hasn't been set. */ |
| VALUE grpc_rb_compression_options_get_default_level(VALUE self) { |
| grpc_compression_level internal_value; |
| VALUE ruby_value = |
| grpc_rb_compression_options_get_default_level_internal_value(self); |
| |
| if (RTEST(ruby_value)) { |
| internal_value = (grpc_compression_level)NUM2INT(ruby_value); |
| return grpc_rb_compression_options_level_value_to_name_internal( |
| internal_value); |
| } |
| |
| return Qnil; |
| } |
| |
| /* Gets a list of the disabled algorithms as readable names. |
| * Returns an empty list of no algorithms have been disabled. */ |
| VALUE grpc_rb_compression_options_get_disabled_algorithms(VALUE self) { |
| VALUE disabled_algorithms = rb_ary_new(); |
| grpc_compression_algorithm internal_value; |
| grpc_rb_compression_options *wrapper = NULL; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| |
| for (internal_value = GRPC_COMPRESS_NONE; |
| internal_value < GRPC_COMPRESS_ALGORITHMS_COUNT; internal_value++) { |
| if (!grpc_compression_options_is_algorithm_enabled(wrapper->wrapped, |
| internal_value)) { |
| rb_ary_push(disabled_algorithms, |
| grpc_rb_compression_options_algorithm_value_to_name_internal( |
| internal_value)); |
| } |
| } |
| return disabled_algorithms; |
| } |
| |
| /* Provides a bitset as a ruby number that is suitable to pass to |
| * the GRPC core as a channel argument to enable compression algorithms. */ |
| VALUE grpc_rb_compression_options_get_enabled_algorithms_bitset(VALUE self) { |
| grpc_rb_compression_options *wrapper = NULL; |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| return INT2NUM((int)wrapper->wrapped->enabled_algorithms_bitset); |
| } |
| |
| /* Initializes the compression options wrapper. |
| * Takes an optional hash parameter. |
| * |
| * Example call-seq: |
| * options = CompressionOptions.new( |
| * default_level: :none, |
| * disabled_algorithms: [:gzip] |
| * ) |
| * channel_arg hash = Hash.new[...] |
| * channel_arg_hash_with_compression_options = channel_arg_hash.merge(options) |
| */ |
| VALUE grpc_rb_compression_options_init(int argc, VALUE *argv, VALUE self) { |
| grpc_rb_compression_options *wrapper = NULL; |
| VALUE default_algorithm = Qnil; |
| VALUE default_level = Qnil; |
| VALUE disabled_algorithms = Qnil; |
| VALUE algorithm_name = Qnil; |
| VALUE hash_arg = Qnil; |
| |
| rb_scan_args(argc, argv, "01", &hash_arg); |
| |
| /* Check if the hash parameter was passed, or if invalid arguments were |
| * passed. */ |
| if (hash_arg == Qnil) { |
| return self; |
| } else if (TYPE(hash_arg) != T_HASH || argc > 1) { |
| rb_raise(rb_eArgError, |
| "Invalid arguments. Expecting optional hash parameter"); |
| } |
| |
| TypedData_Get_Struct(self, grpc_rb_compression_options, |
| &grpc_rb_compression_options_data_type, wrapper); |
| |
| /* Set the default algorithm if one was chosen. */ |
| default_algorithm = |
| rb_hash_aref(hash_arg, ID2SYM(rb_intern("default_algorithm"))); |
| if (default_algorithm != Qnil) { |
| grpc_rb_compression_options_set_default_algorithm(wrapper->wrapped, |
| default_algorithm); |
| } |
| |
| /* Set the default level if one was chosen. */ |
| default_level = rb_hash_aref(hash_arg, ID2SYM(rb_intern("default_level"))); |
| if (default_level != Qnil) { |
| grpc_rb_compression_options_set_default_level(wrapper->wrapped, |
| default_level); |
| } |
| |
| /* Set the disabled algorithms if any were chosen. */ |
| disabled_algorithms = |
| rb_hash_aref(hash_arg, ID2SYM(rb_intern("disabled_algorithms"))); |
| if (disabled_algorithms != Qnil) { |
| Check_Type(disabled_algorithms, T_ARRAY); |
| |
| for (int i = 0; i < RARRAY_LEN(disabled_algorithms); i++) { |
| algorithm_name = rb_ary_entry(disabled_algorithms, i); |
| grpc_rb_compression_options_disable_algorithm(wrapper->wrapped, |
| algorithm_name); |
| } |
| } |
| |
| return self; |
| } |
| |
| void Init_grpc_compression_options() { |
| grpc_rb_cCompressionOptions = rb_define_class_under( |
| grpc_rb_mGrpcCore, "CompressionOptions", rb_cObject); |
| |
| /* Allocates an object managed by the ruby runtime. */ |
| rb_define_alloc_func(grpc_rb_cCompressionOptions, |
| grpc_rb_compression_options_alloc); |
| |
| /* Initializes the ruby wrapper. #new method takes an optional hash argument. |
| */ |
| rb_define_method(grpc_rb_cCompressionOptions, "initialize", |
| grpc_rb_compression_options_init, -1); |
| |
| /* Gets the bitset of enabled algorithms. */ |
| rb_define_method(grpc_rb_cCompressionOptions, "enabled_algorithms_bitset", |
| grpc_rb_compression_options_get_enabled_algorithms_bitset, |
| 0); |
| |
| /* Methods for getting the default algorithm, default level, and disabled |
| * algorithms as readable names. */ |
| rb_define_method(grpc_rb_cCompressionOptions, "default_algorithm", |
| grpc_rb_compression_options_get_default_algorithm, 0); |
| rb_define_method(grpc_rb_cCompressionOptions, "default_level", |
| grpc_rb_compression_options_get_default_level, 0); |
| rb_define_method(grpc_rb_cCompressionOptions, "disabled_algorithms", |
| grpc_rb_compression_options_get_disabled_algorithms, 0); |
| |
| /* Methods for getting the internal enum default algorithm and level enum |
| * values of an instance. */ |
| rb_define_method( |
| grpc_rb_cCompressionOptions, "default_algorithm_internal_value", |
| grpc_rb_compression_options_get_default_algorithm_internal_value, 0); |
| rb_define_method(grpc_rb_cCompressionOptions, "default_level_internal_value", |
| grpc_rb_compression_options_get_default_level_internal_value, |
| 0); |
| |
| /* Determines whether or not an algorithm is enabled, given a readable |
| * algorithm name.*/ |
| rb_define_method(grpc_rb_cCompressionOptions, "is_algorithm_enabled", |
| grpc_rb_compression_options_is_algorithm_enabled, 1); |
| |
| /* Methods for converting to and from algorithm enum values and their readable |
| * names. */ |
| rb_define_singleton_method( |
| grpc_rb_cCompressionOptions, "algorithm_name_to_value", |
| grpc_rb_compression_options_algorithm_name_to_value, 1); |
| rb_define_singleton_method( |
| grpc_rb_cCompressionOptions, "algorithm_value_to_name", |
| grpc_rb_compression_options_algorithm_value_to_name, 1); |
| |
| /* Methods for converting to and from compression level enum values and their |
| * readable names. */ |
| rb_define_singleton_method(grpc_rb_cCompressionOptions, "level_name_to_value", |
| grpc_rb_compression_options_level_name_to_value, |
| 1); |
| rb_define_singleton_method(grpc_rb_cCompressionOptions, "level_value_to_name", |
| grpc_rb_compression_options_level_value_to_name, |
| 1); |
| |
| /* Provides a hash of the compression settings suitable |
| * for passing to server or channel args. */ |
| rb_define_method(grpc_rb_cCompressionOptions, "to_hash", |
| grpc_rb_compression_options_to_hash, 0); |
| rb_define_alias(grpc_rb_cCompressionOptions, "to_channel_arg_hash", |
| "to_hash"); |
| |
| /* Ruby symbols for the names of the different compression levels. */ |
| rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_NONE_SYM", |
| ID2SYM(rb_intern("none"))); |
| rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_LOW_SYM", |
| ID2SYM(rb_intern("low"))); |
| rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_MEDIUM_SYM", |
| ID2SYM(rb_intern("medium"))); |
| rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_HIGH_SYM", |
| ID2SYM(rb_intern("high"))); |
| } |