void define_ruby_class() { if (rb_klass) return; /* * opencv = rb_define_module("OpenCV"); * * note: this comment is used by rdoc. */ VALUE opencv = rb_module_opencv(); rb_klass = rb_define_class_under(opencv, "CvCapture", rb_cData); VALUE video_interface = rb_hash_new(); /* {:any, :mil, :vfw, :v4l, :v4l2, :fireware, :ieee1394, :dc1394, :cmu1394, :stereo, :tyzx, :tyzx_left, :tyzx_right, :tyzx_color, :tyzx_z, :qt, :qtuicktime}: video source */ rb_define_const(rb_klass, "INTERFACE", video_interface); rb_hash_aset(video_interface, ID2SYM(rb_intern("any")), INT2FIX(CV_CAP_ANY)); rb_hash_aset(video_interface, ID2SYM(rb_intern("mil")), INT2FIX(CV_CAP_MIL)); rb_hash_aset(video_interface, ID2SYM(rb_intern("vfw")), INT2FIX(CV_CAP_VFW)); rb_hash_aset(video_interface, ID2SYM(rb_intern("v4l")), INT2FIX(CV_CAP_V4L)); rb_hash_aset(video_interface, ID2SYM(rb_intern("v4l2")), INT2FIX(CV_CAP_V4L2)); rb_hash_aset(video_interface, ID2SYM(rb_intern("fireware")), INT2FIX(CV_CAP_FIREWARE)); rb_hash_aset(video_interface, ID2SYM(rb_intern("ieee1394")), INT2FIX(CV_CAP_IEEE1394)); rb_hash_aset(video_interface, ID2SYM(rb_intern("dc1394")), INT2FIX(CV_CAP_DC1394)); rb_hash_aset(video_interface, ID2SYM(rb_intern("cmu1394")), INT2FIX(CV_CAP_CMU1394)); rb_hash_aset(video_interface, ID2SYM(rb_intern("stereo")), INT2FIX(CV_CAP_STEREO)); rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx")), INT2FIX(CV_CAP_TYZX)); rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_left")), INT2FIX(CV_TYZX_LEFT)); rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_right")), INT2FIX(CV_TYZX_RIGHT)); rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_color")), INT2FIX(CV_TYZX_COLOR)); rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_z")), INT2FIX(CV_TYZX_Z)); rb_hash_aset(video_interface, ID2SYM(rb_intern("qt")), INT2FIX(CV_CAP_QT)); rb_hash_aset(video_interface, ID2SYM(rb_intern("quicktime")), INT2FIX(CV_CAP_QT)); rb_define_singleton_method(rb_klass, "open", RUBY_METHOD_FUNC(rb_open), -1); rb_define_method(rb_klass, "grab", RUBY_METHOD_FUNC(rb_grab), 0); rb_define_method(rb_klass, "retrieve", RUBY_METHOD_FUNC(rb_retrieve), 0); rb_define_method(rb_klass, "query", RUBY_METHOD_FUNC(rb_query), 0); rb_define_method(rb_klass, "millisecond", RUBY_METHOD_FUNC(rb_get_millisecond), 0); rb_define_method(rb_klass, "millisecond=", RUBY_METHOD_FUNC(rb_set_millisecond), 1); rb_define_method(rb_klass, "frames", RUBY_METHOD_FUNC(rb_get_frames), 0); rb_define_method(rb_klass, "frames=", RUBY_METHOD_FUNC(rb_set_frames), 1); rb_define_method(rb_klass, "avi_ratio", RUBY_METHOD_FUNC(rb_get_avi_ratio), 0); rb_define_method(rb_klass, "avi_ratio=", RUBY_METHOD_FUNC(rb_set_avi_ratio), 1); rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_get_size), 0); rb_define_method(rb_klass, "size=", RUBY_METHOD_FUNC(rb_set_size), 1); rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_get_width), 0); rb_define_method(rb_klass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1); rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_get_height), 0); rb_define_method(rb_klass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1); rb_define_method(rb_klass, "fps", RUBY_METHOD_FUNC(rb_get_fps), 0); rb_define_method(rb_klass, "fps=", RUBY_METHOD_FUNC(rb_set_fps), 1); rb_define_method(rb_klass, "fourcc", RUBY_METHOD_FUNC(rb_get_fourcc), 0); rb_define_method(rb_klass, "frame_count", RUBY_METHOD_FUNC(rb_get_frame_count), 0); rb_define_method(rb_klass, "format", RUBY_METHOD_FUNC(rb_get_format), 0); rb_define_method(rb_klass, "mode", RUBY_METHOD_FUNC(rb_get_mode), 0); rb_define_method(rb_klass, "brightness", RUBY_METHOD_FUNC(rb_get_brightness), 0); rb_define_method(rb_klass, "contrast", RUBY_METHOD_FUNC(rb_get_contrast), 0); rb_define_method(rb_klass, "saturation", RUBY_METHOD_FUNC(rb_get_saturation), 0); rb_define_method(rb_klass, "hue", RUBY_METHOD_FUNC(rb_get_hue), 0); rb_define_method(rb_klass, "gain", RUBY_METHOD_FUNC(rb_get_gain), 0); rb_define_method(rb_klass, "exposure", RUBY_METHOD_FUNC(rb_get_exposure), 0); rb_define_method(rb_klass, "convert_rgb", RUBY_METHOD_FUNC(rb_get_convert_rgb), 0); rb_define_method(rb_klass, "rectification", RUBY_METHOD_FUNC(rb_get_rectification), 0); }
/* * call-seq: to_h * * Returns the configuration instance variables as a hash, that can be * passed to the configure method. */ static VALUE cState_to_h(VALUE self) { VALUE result = rb_hash_new(); GET_STATE(self); rb_hash_aset(result, ID2SYM(i_indent), rb_str_new(state->indent, state->indent_len)); rb_hash_aset(result, ID2SYM(i_space), rb_str_new(state->space, state->space_len)); rb_hash_aset(result, ID2SYM(i_space_before), rb_str_new(state->space_before, state->space_before_len)); rb_hash_aset(result, ID2SYM(i_object_nl), rb_str_new(state->object_nl, state->object_nl_len)); rb_hash_aset(result, ID2SYM(i_array_nl), rb_str_new(state->array_nl, state->array_nl_len)); rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_ascii_only), state->ascii_only ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_quirks_mode), state->quirks_mode ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting)); rb_hash_aset(result, ID2SYM(i_depth), LONG2FIX(state->depth)); rb_hash_aset(result, ID2SYM(i_buffer_initial_length), LONG2FIX(state->buffer_initial_length)); return result; }
/* * Returns the system information obtained by uname system call. * * The return value is a hash which has 5 keys at least: * :sysname, :nodename, :release, :version, :machine * * Example: * * require 'etc' * require 'pp' * * pp Etc.uname * #=> {:sysname=>"Linux", * # :nodename=>"boron", * # :release=>"2.6.18-6-xen-686", * # :version=>"#1 SMP Thu Nov 5 19:54:42 UTC 2009", * # :machine=>"i686"} * */ static VALUE etc_uname(VALUE obj) { #ifdef _WIN32 OSVERSIONINFOW v; SYSTEM_INFO s; const char *sysname, *mach; VALUE result, release, version; VALUE vbuf, nodename = Qnil; DWORD len = 0; WCHAR *buf; v.dwOSVersionInfoSize = sizeof(v); if (!GetVersionExW(&v)) rb_sys_fail("GetVersionEx"); result = rb_hash_new(); switch (v.dwPlatformId) { case VER_PLATFORM_WIN32s: sysname = "Win32s"; break; case VER_PLATFORM_WIN32_NT: sysname = "Windows_NT"; break; case VER_PLATFORM_WIN32_WINDOWS: default: sysname = "Windows"; break; } rb_hash_aset(result, ID2SYM(rb_intern("sysname")), rb_str_new_cstr(sysname)); release = rb_sprintf("%lu.%lu.%lu", v.dwMajorVersion, v.dwMinorVersion, v.dwBuildNumber); rb_hash_aset(result, ID2SYM(rb_intern("release")), release); version = rb_sprintf("%s Version %"PRIsVALUE": %"PRIsVALUE, sysname, release, rb_w32_conv_from_wchar(v.szCSDVersion, rb_utf8_encoding())); rb_hash_aset(result, ID2SYM(rb_intern("version")), version); # if defined _MSC_VER && _MSC_VER < 1300 # define GET_COMPUTER_NAME(ptr, plen) GetComputerNameW(ptr, plen) # else # define GET_COMPUTER_NAME(ptr, plen) GetComputerNameExW(ComputerNameDnsFullyQualified, ptr, plen) # endif GET_COMPUTER_NAME(NULL, &len); buf = ALLOCV_N(WCHAR, vbuf, len); if (GET_COMPUTER_NAME(buf, &len)) { nodename = rb_w32_conv_from_wchar(buf, rb_utf8_encoding()); } ALLOCV_END(vbuf); if (NIL_P(nodename)) nodename = rb_str_new(0, 0); rb_hash_aset(result, ID2SYM(rb_intern("nodename")), nodename); # ifndef PROCESSOR_ARCHITECTURE_AMD64 # define PROCESSOR_ARCHITECTURE_AMD64 9 # endif # ifndef PROCESSOR_ARCHITECTURE_IA64 # define PROCESSOR_ARCHITECTURE_IA64 6 # endif # ifndef PROCESSOR_ARCHITECTURE_INTEL # define PROCESSOR_ARCHITECTURE_INTEL 0 # endif GetSystemInfo(&s); switch (s.wProcessorArchitecture) { case PROCESSOR_ARCHITECTURE_AMD64: mach = "x64"; break; case PROCESSOR_ARCHITECTURE_ARM: mach = "ARM"; break; case PROCESSOR_ARCHITECTURE_IA64: mach = "IA64"; break; case PROCESSOR_ARCHITECTURE_INTEL: mach = "x86"; break; default: mach = "unknown"; break; } rb_hash_aset(result, ID2SYM(rb_intern("machine")), rb_str_new_cstr(mach)); #else struct utsname u; int ret; VALUE result; ret = uname(&u); if (ret == -1) rb_sys_fail("uname"); result = rb_hash_new(); rb_hash_aset(result, ID2SYM(rb_intern("sysname")), rb_str_new_cstr(u.sysname)); rb_hash_aset(result, ID2SYM(rb_intern("nodename")), rb_str_new_cstr(u.nodename)); rb_hash_aset(result, ID2SYM(rb_intern("release")), rb_str_new_cstr(u.release)); rb_hash_aset(result, ID2SYM(rb_intern("version")), rb_str_new_cstr(u.version)); rb_hash_aset(result, ID2SYM(rb_intern("machine")), rb_str_new_cstr(u.machine)); #endif return result; }
int headers_complete_cb(http_parser *p) { VALUE obj, key; client_t *client = get_client(p); request *req = client->req; VALUE env = client->environ; uint32_t i = 0; header *h; if(max_content_length < p->content_length){ client->bad_request_code = 413; return -1; } if (p->http_minor == 1) { obj = rb_str_new2("HTTP/1.1"); } else { obj = rb_str_new2("HTTP/1.0"); } rb_hash_aset(env, server_protocol, obj); if(req->path){ obj = getRbString(req->path); rb_hash_aset(env, path_info, obj); req->path = NULL; } if(req->uri){ obj = getRbString(req->uri); rb_hash_aset(env, request_uri, obj); req->uri = NULL; } if(req->query_string){ obj = getRbString(req->query_string); rb_hash_aset(env, query_string, obj); req->query_string = NULL; } if(req->fragment){ obj = getRbString(req->fragment); rb_hash_aset(env, http_fragment, obj); req->fragment = NULL; } for(i = 0; i < req->num_headers+1; i++){ h = req->headers[i]; if(h){ key = getRbString(h->field); obj = getRbString(h->value); rb_hash_aset(env, key, obj); free_header(h); req->headers[i] = NULL; } } switch(p->method){ case HTTP_DELETE: obj = rb_str_new("DELETE", 6); break; case HTTP_GET: obj = rb_str_new("GET", 3); break; case HTTP_HEAD: obj = rb_str_new("HEAD", 4); break; case HTTP_POST: obj = rb_str_new("POST", 4); break; case HTTP_PUT: obj = rb_str_new("PUT", 3); break; case HTTP_CONNECT: obj = rb_str_new("CONNECT", 7); break; case HTTP_OPTIONS: obj = rb_str_new("OPTIONS", 7); break; case HTTP_TRACE: obj = rb_str_new("TRACE", 5); break; case HTTP_COPY: obj = rb_str_new("COPY", 4); break; case HTTP_LOCK: obj = rb_str_new("LOCK", 4); break; case HTTP_MKCOL: obj = rb_str_new("MKCOL", 5); break; case HTTP_MOVE: obj = rb_str_new("MOVE", 4); break; case HTTP_PROPFIND: obj = rb_str_new("PROPFIND", 8); break; case HTTP_PROPPATCH: obj = rb_str_new("PROPPATCH", 9); break; case HTTP_UNLOCK: obj = rb_str_new("UNLOCK", 6); break; case HTTP_REPORT: obj = rb_str_new("REPORT", 6); break; case HTTP_MKACTIVITY: obj = rb_str_new("MKACTIVITY", 10); break; case HTTP_CHECKOUT: obj = rb_str_new("CHECKOUT", 8); break; case HTTP_MERGE: obj = rb_str_new("MERGE", 5); break; default: obj = rb_str_new("GET", 3); break; } rb_hash_aset(env, request_method, obj); ruby_xfree(req); client->req = NULL; client->body_length = p->content_length; return 0; }
void native_slot_set_value_and_case(const char* name, upb_fieldtype_t type, VALUE type_class, void* memory, VALUE value, uint32_t* case_memory, uint32_t case_number) { // Note that in order to atomically change the value in memory and the case // value (w.r.t. Ruby VM calls), we must set the value at |memory| only after // all Ruby VM calls are complete. The case is then set at the bottom of this // function. switch (type) { case UPB_TYPE_FLOAT: if (!is_ruby_num(value)) { rb_raise(cTypeError, "Expected number type for float field '%s' (given %s).", name, rb_class2name(CLASS_OF(value))); } DEREF(memory, float) = NUM2DBL(value); break; case UPB_TYPE_DOUBLE: if (!is_ruby_num(value)) { rb_raise(cTypeError, "Expected number type for double field '%s' (given %s).", name, rb_class2name(CLASS_OF(value))); } DEREF(memory, double) = NUM2DBL(value); break; case UPB_TYPE_BOOL: { int8_t val = -1; if (value == Qtrue) { val = 1; } else if (value == Qfalse) { val = 0; } else { rb_raise(cTypeError, "Invalid argument for boolean field '%s' (given %s).", name, rb_class2name(CLASS_OF(value))); } DEREF(memory, int8_t) = val; break; } case UPB_TYPE_STRING: if (CLASS_OF(value) == rb_cSymbol) { value = rb_funcall(value, rb_intern("to_s"), 0); } else if (CLASS_OF(value) != rb_cString) { rb_raise(cTypeError, "Invalid argument for string field '%s' (given %s).", name, rb_class2name(CLASS_OF(value))); } DEREF(memory, VALUE) = native_slot_encode_and_freeze_string(type, value); break; case UPB_TYPE_BYTES: { if (CLASS_OF(value) != rb_cString) { rb_raise(cTypeError, "Invalid argument for bytes field '%s' (given %s).", name, rb_class2name(CLASS_OF(value))); } DEREF(memory, VALUE) = native_slot_encode_and_freeze_string(type, value); break; } case UPB_TYPE_MESSAGE: { if (CLASS_OF(value) == CLASS_OF(Qnil)) { value = Qnil; } else if (CLASS_OF(value) != type_class) { // check for possible implicit conversions VALUE converted_value = NULL; char* field_type_name = rb_class2name(type_class); if (strcmp(field_type_name, "Google::Protobuf::Timestamp") == 0 && rb_obj_is_kind_of(value, rb_cTime)) { // Time -> Google::Protobuf::Timestamp VALUE hash = rb_hash_new(); rb_hash_aset(hash, rb_str_new2("seconds"), rb_funcall(value, rb_intern("to_i"), 0)); rb_hash_aset(hash, rb_str_new2("nanos"), rb_funcall(value, rb_intern("nsec"), 0)); VALUE args[1] = { hash }; converted_value = rb_class_new_instance(1, args, type_class); } else if (strcmp(field_type_name, "Google::Protobuf::Duration") == 0 && rb_obj_is_kind_of(value, rb_cNumeric)) { // Numeric -> Google::Protobuf::Duration VALUE hash = rb_hash_new(); rb_hash_aset(hash, rb_str_new2("seconds"), rb_funcall(value, rb_intern("to_i"), 0)); VALUE n_value = rb_funcall(value, rb_intern("remainder"), 1, INT2NUM(1)); n_value = rb_funcall(n_value, rb_intern("*"), 1, INT2NUM(1000000000)); n_value = rb_funcall(n_value, rb_intern("round"), 0); rb_hash_aset(hash, rb_str_new2("nanos"), n_value); VALUE args[1] = { hash }; converted_value = rb_class_new_instance(1, args, type_class); } // raise if no suitable conversaion could be found if (converted_value == NULL) { rb_raise(cTypeError, "Invalid type %s to assign to submessage field '%s'.", rb_class2name(CLASS_OF(value)), name); } else { value = converted_value; } } DEREF(memory, VALUE) = value; break; } case UPB_TYPE_ENUM: { int32_t int_val = 0; if (TYPE(value) == T_STRING) { value = rb_funcall(value, rb_intern("to_sym"), 0); } else if (!is_ruby_num(value) && TYPE(value) != T_SYMBOL) { rb_raise(cTypeError, "Expected number or symbol type for enum field '%s'.", name); } if (TYPE(value) == T_SYMBOL) { // Ensure that the given symbol exists in the enum module. VALUE lookup = rb_funcall(type_class, rb_intern("resolve"), 1, value); if (lookup == Qnil) { rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name); } else { int_val = NUM2INT(lookup); } } else { native_slot_check_int_range_precision(name, UPB_TYPE_INT32, value); int_val = NUM2INT(value); } DEREF(memory, int32_t) = int_val; break; } case UPB_TYPE_INT32: case UPB_TYPE_INT64: case UPB_TYPE_UINT32: case UPB_TYPE_UINT64: native_slot_check_int_range_precision(name, type, value); switch (type) { case UPB_TYPE_INT32: DEREF(memory, int32_t) = NUM2INT(value); break; case UPB_TYPE_INT64: DEREF(memory, int64_t) = NUM2LL(value); break; case UPB_TYPE_UINT32: DEREF(memory, uint32_t) = NUM2UINT(value); break; case UPB_TYPE_UINT64: DEREF(memory, uint64_t) = NUM2ULL(value); break; default: break; } break; default: break; } if (case_memory != NULL) { *case_memory = case_number; } }
/* * Document-Class: Ray::GL * * The GL module is used to give access to low-level OpenGL features in Ray. */ void Init_ray_gl() { ray_mGL = rb_define_module_under(ray_mRay, "GL"); ray_gl_primitives = rb_hash_new(); rb_hash_aset(ray_gl_primitives, RAY_SYM("points"), INT2FIX(GL_POINTS)); rb_hash_aset(ray_gl_primitives, RAY_SYM("line_strip"), INT2FIX(GL_LINE_STRIP)); rb_hash_aset(ray_gl_primitives, RAY_SYM("line_loop"), INT2FIX(GL_LINE_LOOP)); rb_hash_aset(ray_gl_primitives, RAY_SYM("lines"), INT2FIX(GL_LINES)); rb_hash_aset(ray_gl_primitives, RAY_SYM("triangle_strip"), INT2FIX(GL_TRIANGLE_STRIP)); rb_hash_aset(ray_gl_primitives, RAY_SYM("triangle_fan"), INT2FIX(GL_TRIANGLE_FAN)); rb_hash_aset(ray_gl_primitives, RAY_SYM("triangles"), INT2FIX(GL_TRIANGLES)); /* @return [Hash] Available primitives. */ rb_define_const(ray_mGL, "Primitives", ray_gl_primitives); /* @group Context configuration */ rb_define_module_function(ray_mGL, "depth_size", ray_gl_depth_size, 0); rb_define_module_function(ray_mGL, "depth_size=", ray_gl_set_depth_size, 1); rb_define_module_function(ray_mGL, "stencil_size", ray_gl_stencil_size, 0); rb_define_module_function(ray_mGL, "stencil_size=", ray_gl_set_stencil_size, 1); rb_define_module_function(ray_mGL, "major_version", ray_gl_major_version, 0); rb_define_module_function(ray_mGL, "major_version=", ray_gl_set_major_version, 1); rb_define_module_function(ray_mGL, "minor_version", ray_gl_minor_version, 0); rb_define_module_function(ray_mGL, "minor_version=", ray_gl_set_minor_version, 1); rb_define_module_function(ray_mGL, "core_profile?", ray_gl_core_profile, 0); rb_define_module_function(ray_mGL, "core_profile=", ray_gl_set_core_profile, 1); rb_define_module_function(ray_mGL, "debug?", ray_gl_debug, 0); rb_define_module_function(ray_mGL, "debug=", ray_gl_set_debug, 1); /* @endgroup */ /* @group Low-level rendering */ rb_define_module_function(ray_mGL, "draw_arrays", ray_gl_draw_arrays, 3); rb_define_module_function(ray_mGL, "draw_elements", ray_gl_draw_elements, 3); rb_define_module_function(ray_mGL, "draw_arrays_instanced", ray_gl_draw_arrays_instanced, 4); rb_define_module_function(ray_mGL, "draw_elements_instanced", ray_gl_draw_elements_instanced, 4); rb_define_module_function(ray_mGL, "multi_draw_arrays", ray_gl_multi_draw_arrays, 3); rb_define_module_function(ray_mGL, "multi_draw_elements", ray_gl_multi_draw_elements, 3); /* @endgroup */ rb_define_module_function(ray_mGL, "has_callback?", ray_gl_has_callback, 0); rb_define_module_function(ray_mGL, "callback=", ray_gl_set_callback, 1); rb_define_module_function(ray_mGL, "ensure_context", ray_gl_ensure_context, 0); }
static VALUE rb_thread_aset(VALUE self, SEL sel, ID key, VALUE val) { key = ID2SYM(rb_to_id(key)); return rb_hash_aset(rb_vm_thread_locals(self, true), key, val); }
void rho_ruby_add_to_hash(VALUE hash, VALUE key, VALUE item) { rb_hash_aset(hash, key, item); }
VALUE addTimeToHash(VALUE hash, const char* key, time_t val) { return rb_hash_aset(hash, rb_str_new2(key), rb_time_new(val,0)); }
static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast, MYSQL_FIELD * fields) { VALUE rowVal; mysql2_result_wrapper * wrapper; MYSQL_ROW row; unsigned int i = 0; unsigned long * fieldLengths; void * ptr; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc; rb_encoding *conn_enc; #endif GetMysql2Result(self, wrapper); #ifdef HAVE_RUBY_ENCODING_H default_internal_enc = rb_default_internal_encoding(); conn_enc = rb_to_encoding(wrapper->encoding); #endif ptr = wrapper->result; row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0); if (row == NULL) { return Qnil; } if (asArray) { rowVal = rb_ary_new2(wrapper->numberOfFields); } else { rowVal = rb_hash_new(); } fieldLengths = mysql_fetch_lengths(wrapper->result); if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys); if (row[i]) { VALUE val = Qnil; enum enum_field_types type = fields[i].type; if(!cast) { if (type == MYSQL_TYPE_NULL) { val = Qnil; } else { val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif } } else { switch(type) { case MYSQL_TYPE_NULL: // NULL-type field val = Qnil; break; case MYSQL_TYPE_BIT: // BIT field (MySQL 5.0.3 and up) val = rb_str_new(row[i], fieldLengths[i]); break; case MYSQL_TYPE_TINY: // TINYINT field if (castBool && fields[i].length == 1) { val = *row[i] == '1' ? Qtrue : Qfalse; break; } case MYSQL_TYPE_SHORT: // SMALLINT field case MYSQL_TYPE_LONG: // INTEGER field case MYSQL_TYPE_INT24: // MEDIUMINT field case MYSQL_TYPE_LONGLONG: // BIGINT field case MYSQL_TYPE_YEAR: // YEAR field val = rb_cstr2inum(row[i], 10); break; case MYSQL_TYPE_DECIMAL: // DECIMAL or NUMERIC field case MYSQL_TYPE_NEWDECIMAL: // Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up) if (fields[i].decimals == 0) { val = rb_cstr2inum(row[i], 10); } else if (strtod(row[i], NULL) == 0.000000){ val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero); }else{ val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i])); } break; case MYSQL_TYPE_FLOAT: // FLOAT field case MYSQL_TYPE_DOUBLE: { // DOUBLE or REAL field double column_to_double; column_to_double = strtod(row[i], NULL); if (column_to_double == 0.000000){ val = opt_float_zero; }else{ val = rb_float_new(column_to_double); } break; } case MYSQL_TYPE_TIME: { // TIME field int hour, min, sec, tokens; tokens = sscanf(row[i], "%2d:%2d:%2d", &hour, &min, &sec); val = rb_funcall(rb_cTime, db_timezone, 6, opt_time_year, opt_time_month, opt_time_month, INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } break; } case MYSQL_TYPE_TIMESTAMP: // TIMESTAMP field case MYSQL_TYPE_DATETIME: { // DATETIME field unsigned int year, month, day, hour, min, sec, tokens; uint64_t seconds; tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec); seconds = (year*31557600ULL) + (month*2592000ULL) + (day*86400ULL) + (hour*3600ULL) + (min*60ULL) + sec; if (seconds == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { if (seconds < MYSQL2_MIN_TIME || seconds >= MYSQL2_MAX_TIME) { // use DateTime instead VALUE offset = INT2NUM(0); if (db_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); } val = rb_funcall(cDateTime, intern_civil, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), offset); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); val = rb_funcall(val, intern_new_offset, 1, offset); } else { // utc val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset); } } } else { val = rb_funcall(rb_cTime, db_timezone, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } } } } break; } case MYSQL_TYPE_DATE: // DATE field case MYSQL_TYPE_NEWDATE: { // Newer const used > 5.0 int year, month, day, tokens; tokens = sscanf(row[i], "%4d-%2d-%2d", &year, &month, &day); if (year+month+day == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { val = rb_funcall(cDate, intern_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day)); } } break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_STRING: // CHAR or BINARY field case MYSQL_TYPE_SET: // SET field case MYSQL_TYPE_ENUM: // ENUM field case MYSQL_TYPE_GEOMETRY: // Spatial fielda default: val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif break; } } if (asArray) { rb_ary_push(rowVal, val); } else { rb_hash_aset(rowVal, field, val); } } else { if (asArray) { rb_ary_push(rowVal, Qnil); } else { rb_hash_aset(rowVal, field, Qnil); } } } return rowVal; }
static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast, MYSQL_FIELD * fields) { VALUE rowVal; mysql2_result_wrapper * wrapper; MYSQL_ROW row; unsigned int i = 0; unsigned long * fieldLengths; void * ptr; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc; rb_encoding *conn_enc; #endif GetMysql2Result(self, wrapper); #ifdef HAVE_RUBY_ENCODING_H default_internal_enc = rb_default_internal_encoding(); conn_enc = rb_to_encoding(wrapper->encoding); #endif ptr = wrapper->result; row = (MYSQL_ROW)rb_thread_call_without_gvl(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0); if (row == NULL) { return Qnil; } if (asArray) { rowVal = rb_ary_new2(wrapper->numberOfFields); } else { rowVal = rb_hash_new(); } fieldLengths = mysql_fetch_lengths(wrapper->result); if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys); if (row[i]) { VALUE val = Qnil; enum enum_field_types type = fields[i].type; if(!cast) { if (type == MYSQL_TYPE_NULL) { val = Qnil; } else { val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif } } else { switch(type) { case MYSQL_TYPE_NULL: /* NULL-type field */ val = Qnil; break; case MYSQL_TYPE_BIT: /* BIT field (MySQL 5.0.3 and up) */ if (castBool && fields[i].length == 1) { val = *row[i] == 1 ? Qtrue : Qfalse; }else{ val = rb_str_new(row[i], fieldLengths[i]); } break; case MYSQL_TYPE_TINY: /* TINYINT field */ if (castBool && fields[i].length == 1) { val = *row[i] != '0' ? Qtrue : Qfalse; break; } case MYSQL_TYPE_SHORT: /* SMALLINT field */ case MYSQL_TYPE_LONG: /* INTEGER field */ case MYSQL_TYPE_INT24: /* MEDIUMINT field */ case MYSQL_TYPE_LONGLONG: /* BIGINT field */ case MYSQL_TYPE_YEAR: /* YEAR field */ val = rb_cstr2inum(row[i], 10); break; case MYSQL_TYPE_DECIMAL: /* DECIMAL or NUMERIC field */ case MYSQL_TYPE_NEWDECIMAL: /* Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up) */ if (fields[i].decimals == 0) { val = rb_cstr2inum(row[i], 10); } else if (strtod(row[i], NULL) == 0.000000){ val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero); }else{ val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i])); } break; case MYSQL_TYPE_FLOAT: /* FLOAT field */ case MYSQL_TYPE_DOUBLE: { /* DOUBLE or REAL field */ double column_to_double; column_to_double = strtod(row[i], NULL); if (column_to_double == 0.000000){ val = opt_float_zero; }else{ val = rb_float_new(column_to_double); } break; } case MYSQL_TYPE_TIME: { /* TIME field */ int tokens; unsigned int hour=0, min=0, sec=0; tokens = sscanf(row[i], "%2u:%2u:%2u", &hour, &min, &sec); if (tokens < 3) { val = Qnil; break; } val = rb_funcall(rb_cTime, db_timezone, 6, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { /* utc */ val = rb_funcall(val, intern_utc, 0); } } break; } case MYSQL_TYPE_TIMESTAMP: /* TIMESTAMP field */ case MYSQL_TYPE_DATETIME: { /* DATETIME field */ int tokens; unsigned int year=0, month=0, day=0, hour=0, min=0, sec=0, msec=0; char msec_char[7] = {'0','0','0','0','0','0','\0'}; uint64_t seconds; tokens = sscanf(row[i], "%4u-%2u-%2u %2u:%2u:%2u.%6s", &year, &month, &day, &hour, &min, &sec, msec_char); if (tokens < 6) { /* msec might be empty */ val = Qnil; break; } seconds = (year*31557600ULL) + (month*2592000ULL) + (day*86400ULL) + (hour*3600ULL) + (min*60ULL) + sec; if (seconds == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { /* use DateTime for larger date range, does not support microseconds */ VALUE offset = INT2NUM(0); if (db_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); } val = rb_funcall(cDateTime, intern_civil, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), offset); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); val = rb_funcall(val, intern_new_offset, 1, offset); } else { /* utc */ val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset); } } } else { /* microseconds can be up to 6 digits. Fewer digits must be interpreted from * the left because the microseconds are to the right of the decimal point. */ if (tokens == 7) { int i; for (i = 0; i < 6; ++i) { if (msec_char[i] == '\0') { msec_char[i] = '0'; } } msec = (unsigned int)strtoul(msec_char, NULL, 10); } val = rb_funcall(rb_cTime, db_timezone, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { /* utc */ val = rb_funcall(val, intern_utc, 0); } } } } } break; } case MYSQL_TYPE_DATE: /* DATE field */ case MYSQL_TYPE_NEWDATE: { /* Newer const used > 5.0 */ int tokens; unsigned int year=0, month=0, day=0; tokens = sscanf(row[i], "%4u-%2u-%2u", &year, &month, &day); if (tokens < 3) { val = Qnil; break; } if (year+month+day == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { val = rb_funcall(cDate, intern_new, 3, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day)); } } break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_STRING: /* CHAR or BINARY field */ case MYSQL_TYPE_SET: /* SET field */ case MYSQL_TYPE_ENUM: /* ENUM field */ case MYSQL_TYPE_GEOMETRY: /* Spatial fielda */ default: val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif break; } } if (asArray) { rb_ary_push(rowVal, val); } else { rb_hash_aset(rowVal, field, val); } } else { if (asArray) { rb_ary_push(rowVal, Qnil); } else { rb_hash_aset(rowVal, field, Qnil); } } } return rowVal; }
static VALUE rhe_accept(VALUE self, VALUE fileno, VALUE timeoutv, VALUE tcp, VALUE env) { struct sockaddr_in cliaddr; unsigned int len; char read_buf[MAX_HEADER_SIZE]; VALUE req; int flag = 1; ssize_t rv = 0; ssize_t buf_len; ssize_t reqlen; int fd; double timeout = NUM2DBL(timeoutv); len = sizeof(cliaddr); fd = _accept(NUM2INT(fileno), (struct sockaddr *)&cliaddr, len); /* endif */ if (fd < 0) { goto badexit; } rv = _read_timeout(fd, timeout, &read_buf[0], MAX_HEADER_SIZE); if ( rv <= 0 ) { close(fd); goto badexit; } if ( IMMEDIATE_P(tcp) ) { setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int)); rb_hash_aset(env, remote_addr_key, rb_str_new2(inet_ntoa(cliaddr.sin_addr))); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(ntohs(cliaddr.sin_port)))); } else { rb_hash_aset(env, remote_addr_key, rb_str_new("",0)); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(0))); } buf_len = rv; while (1) { reqlen = _parse_http_request(&read_buf[0],buf_len,env); if ( reqlen >= 0 ) { break; } else if ( reqlen == -1 ) { /* error */ close(fd); goto badexit; } if ( MAX_HEADER_SIZE - buf_len == 0 ) { /* too large header */ char* badreq; badreq = BAD_REQUEST; rv = _write_timeout(fd, timeout, badreq, sizeof(BAD_REQUEST) - 1); close(fd); goto badexit; } /* request is incomplete */ rv = _read_timeout(fd, timeout, &read_buf[buf_len], MAX_HEADER_SIZE - buf_len); if ( rv <= 0 ) { close(fd); goto badexit; } buf_len += rv; } req = rb_ary_new2(3); rb_ary_push(req, rb_int_new(fd)); rb_ary_push(req, rb_str_new(&read_buf[reqlen],buf_len - reqlen)); return req; badexit: return Qnil; }
static int _parse_http_request(char *buf, ssize_t buf_len, VALUE env) { const char* method; size_t method_len; const char* path; size_t path_len; int minor_version; struct phr_header headers[MAX_HEADERS]; size_t num_headers, question_at; size_t i; int ret; char tmp[MAX_HEADER_NAME_LEN + sizeof("HTTP_") - 1]; VALUE last_value; num_headers = MAX_HEADERS; ret = phr_parse_request(buf, buf_len, &method, &method_len, &path, &path_len, &minor_version, headers, &num_headers, 0); if (ret < 0) goto done; rb_hash_aset(env, request_method_key, rb_str_new(method,method_len)); rb_hash_aset(env, request_uri_key, rb_str_new(path, path_len)); rb_hash_aset(env, script_name_key, rb_str_new2("")); strcpy(tmp, "HTTP/1."); tmp[7] = 48 + ((minor_version > 1 || minor_version < 0 ) ? 0 : minor_version); rb_hash_aset(env, server_protocol_key, rb_str_new(tmp, sizeof("HTTP/1.0") - 1)); /* PATH_INFO QUERY_STRING */ path_len = find_ch(path, path_len, '#'); /* strip off all text after # after storing request_uri */ question_at = find_ch(path, path_len, '?'); if ( store_path_info(env, path, question_at) < 0 ) { rb_hash_clear(env); ret = -1; goto done; } if (question_at != path_len) ++question_at; rb_hash_aset(env, query_string_key, rb_str_new(path + question_at, path_len - question_at)); last_value = Qnil; for (i = 0; i < num_headers; ++i) { if (headers[i].name != NULL) { const char* name; size_t name_len; VALUE slot; VALUE env_key; env_key = find_common_header(headers + i); if ( env_key == Qnil ) { const char* s; char* d; size_t n; if (sizeof(tmp) - 5 < headers[i].name_len) { rb_hash_clear(env); ret = -1; goto done; } strcpy(tmp, "HTTP_"); for (s = headers[i].name, n = headers[i].name_len, d = tmp + 5; n != 0; s++, --n, d++) { *d = *s == '-' ? '_' : TOU(*s); name = tmp; name_len = headers[i].name_len + 5; env_key = rb_str_new(name, name_len); } } slot = rb_hash_aref(env, env_key); if ( slot != Qnil ) { rb_str_cat2(slot, ", "); rb_str_cat(slot, headers[i].value, headers[i].value_len); } else { slot = rb_str_new(headers[i].value, headers[i].value_len); rb_hash_aset(env, env_key, slot); last_value = slot; } } else { /* continuing lines of a mulitiline header */ if ( last_value != Qnil ) rb_str_cat(last_value, headers[i].value, headers[i].value_len); } } done: return ret; }
void cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation, lcb_error_t error, const lcb_store_resp_t *resp) { struct cb_context_st *ctx = (struct cb_context_st *)cookie; struct cb_bucket_st *bucket = ctx->bucket; VALUE key, cas, exc, res; key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey); cb_strip_key_prefix(bucket, key); cas = resp->v.v0.cas > 0 ? ULL2NUM(resp->v.v0.cas) : Qnil; switch(operation) { case LCB_ADD: ctx->operation = cb_sym_add; break; case LCB_REPLACE: ctx->operation = cb_sym_replace; break; case LCB_SET: ctx->operation = cb_sym_set; break; case LCB_APPEND: ctx->operation = cb_sym_append; break; case LCB_PREPEND: ctx->operation = cb_sym_prepend; break; default: ctx->operation = Qnil; } exc = cb_check_error(error, "failed to store value", key); if (exc != Qnil) { rb_ivar_set(exc, cb_id_iv_cas, cas); rb_ivar_set(exc, cb_id_iv_operation, ctx->operation); ctx->exception = exc; } if (bucket->async) { /* asynchronous */ if (RTEST(ctx->observe_options)) { VALUE args[2]; /* it's ok to pass pointer to stack struct here */ args[0] = rb_hash_new(); rb_hash_aset(args[0], key, cas); args[1] = ctx->observe_options; rb_block_call(bucket->self, cb_id_observe_and_wait, 2, args, storage_observe_callback, (VALUE)ctx); ctx->observe_options = Qnil; } else if (ctx->proc != Qnil) { res = rb_class_new_instance(0, NULL, cb_cResult); rb_ivar_set(res, cb_id_iv_error, exc); rb_ivar_set(res, cb_id_iv_key, key); rb_ivar_set(res, cb_id_iv_operation, ctx->operation); rb_ivar_set(res, cb_id_iv_cas, cas); cb_proc_call(bucket, ctx->proc, 1, res); } } else { /* synchronous */ rb_hash_aset(ctx->rv, key, cas); } if (!RTEST(ctx->observe_options)) { ctx->nqueries--; if (ctx->nqueries == 0) { ctx->proc = Qnil; if (bucket->async) { cb_context_free(ctx); } } } (void)handle; }
/* @api private */ VALUE rb_do_kcluster(int argc, VALUE *argv, VALUE self) { VALUE size, data, mask, weights, options; rb_scan_args(argc, argv, "21", &size, &data, &options); if (TYPE(data) != T_ARRAY) rb_raise(rb_eArgError, "data should be an array of arrays"); if (NIL_P(size) || NUM2INT(rb_Integer(size)) > RARRAY_LEN(data)) rb_raise(rb_eArgError, "size should be > 0 and <= data size"); mask = get_value_option(options, "mask", Qnil); if (!NIL_P(mask) && TYPE(mask) != T_ARRAY) rb_raise(rb_eArgError, "mask should be an array of arrays"); int transpose = get_bool_option(options, "transpose", 0); int npass = get_int_option(options, "iterations", DEFAULT_ITERATIONS); // a = average, m = means int method = get_int_option(options, "method", 'a'); // e = euclidian, // b = city-block distance // c = correlation // a = absolute value of the correlation // u = uncentered correlation // x = absolute uncentered correlation // s = spearman's rank correlation // k = kendall's tau int dist = get_int_option(options, "metric", 'e'); // initial assignment int assign = get_int_option(options, "seed", 0); int i,j; int nrows = RARRAY_LEN(data); int ncols = RARRAY_LEN(rb_ary_entry(data, 0)); int nsets = NUM2INT(rb_Integer(size)); double **cdata = (double**)malloc(sizeof(double*)*nrows); int **cmask = (int **)malloc(sizeof(int *)*nrows); double *cweights = (double *)malloc(sizeof(double )*ncols); double **ccentroid; int *ccluster, **ccentroid_mask, dimx = nrows, dimy = ncols, cdimx = nsets, cdimy = ncols; for (i = 0; i < nrows; i++) { cdata[i] = (double*)malloc(sizeof(double)*ncols); cmask[i] = (int *)malloc(sizeof(int )*ncols); for (j = 0; j < ncols; j++) { cdata[i][j] = NUM2DBL(rb_Float(rb_ary_entry(rb_ary_entry(data, i), j))); cmask[i][j] = NIL_P(mask) ? 1 : NUM2INT(rb_Integer(rb_ary_entry(rb_ary_entry(mask, i), j))); } } weights = NIL_P(options) ? Qnil : rb_hash_aref(options, ID2SYM(rb_intern("weights"))); for (i = 0; i < ncols; i++) { cweights[i] = NIL_P(weights) ? 1.0 : NUM2DBL(rb_Float(rb_ary_entry(weights, i))); } if (transpose) { dimx = ncols; dimy = nrows; cdimx = nrows; cdimy = nsets; } ccluster = (int *)malloc(sizeof(int )*dimx); ccentroid = (double**)malloc(sizeof(double*)*cdimx); ccentroid_mask = (int **)malloc(sizeof(int *)*cdimx); for (i = 0; i < cdimx; i++) { ccentroid[i] = (double*)malloc(sizeof(double)*cdimy); ccentroid_mask[i] = (int *)malloc(sizeof(int )*cdimy); } int ifound; double error; kcluster(nsets, nrows, ncols, cdata, cmask, cweights, transpose, npass, method, dist, ccluster, &error, &ifound, assign); getclustercentroids(nsets, nrows, ncols, cdata, cmask, ccluster, ccentroid, ccentroid_mask, transpose, method); VALUE result = rb_hash_new(); VALUE cluster = rb_ary_new(); VALUE centroid = rb_ary_new(); for (i = 0; i < dimx; i++) rb_ary_push(cluster, INT2NUM(ccluster[i])); for (i = 0; i < cdimx; i++) { VALUE point = rb_ary_new(); for (j = 0; j < cdimy; j++) rb_ary_push(point, DBL2NUM(ccentroid[i][j])); rb_ary_push(centroid, point); } rb_hash_aset(result, ID2SYM(rb_intern("cluster")), cluster); rb_hash_aset(result, ID2SYM(rb_intern("centroid")), centroid); rb_hash_aset(result, ID2SYM(rb_intern("error")), DBL2NUM(error)); rb_hash_aset(result, ID2SYM(rb_intern("repeated")), INT2NUM(ifound)); for (i = 0; i < nrows; i++) { free(cdata[i]); free(cmask[i]); } for (i = 0; i < cdimx; i++) { free(ccentroid[i]); free(ccentroid_mask[i]); } free(cdata); free(cmask); free(ccentroid); free(ccentroid_mask); free(cweights); free(ccluster); return result; }
VALUE addIntToHash(VALUE hash, const char* key, int val) { return rb_hash_aset(hash, rb_str_new2(key), INT2FIX(val)); }
static VALUE rb_git_indexentry_fromC(const git_index_entry *entry) { VALUE rb_entry, rb_mtime, rb_ctime; unsigned int valid, stage; if (!entry) return Qnil; rb_entry = rb_hash_new(); rb_hash_aset(rb_entry, CSTR2SYM("path"), rb_str_new_utf8(entry->path)); rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(&entry->id)); rb_hash_aset(rb_entry, CSTR2SYM("dev"), INT2FIX(entry->dev)); rb_hash_aset(rb_entry, CSTR2SYM("ino"), INT2FIX(entry->ino)); rb_hash_aset(rb_entry, CSTR2SYM("mode"), INT2FIX(entry->mode)); rb_hash_aset(rb_entry, CSTR2SYM("gid"), INT2FIX(entry->gid)); rb_hash_aset(rb_entry, CSTR2SYM("uid"), INT2FIX(entry->uid)); rb_hash_aset(rb_entry, CSTR2SYM("file_size"), INT2FIX(entry->file_size)); valid = (entry->flags & GIT_IDXENTRY_VALID); rb_hash_aset(rb_entry, CSTR2SYM("valid"), valid ? Qtrue : Qfalse); stage = (entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT; rb_hash_aset(rb_entry, CSTR2SYM("stage"), INT2FIX(stage)); rb_mtime = rb_time_new(entry->mtime.seconds, entry->mtime.nanoseconds / 1000); rb_ctime = rb_time_new(entry->ctime.seconds, entry->ctime.nanoseconds / 1000); rb_hash_aset(rb_entry, CSTR2SYM("ctime"), rb_ctime); rb_hash_aset(rb_entry, CSTR2SYM("mtime"), rb_mtime); return rb_entry; }
VALUE addBoolToHash(VALUE hash, const char* key, int val) { return rb_hash_aset(hash, rb_str_new2(key), (val ? Qtrue : Qfalse) ); }
/** * Custom marshal for Draw objects. * * Ruby usage: * - @verbatim Draw#marshal_dump @endverbatim * * Notes: * - Instead of trying to replicate Ruby's support for cross-system * marshalling, exploit it. Convert the Draw fields to Ruby objects and * store them in a hash. Let Ruby marshal the hash. * - Commented out code that dumps/loads fields that are used internally by * ImageMagick and shouldn't be marshaled. I left the code as placeholders * so I'll know which fields have been deliberately omitted. * * @param self this object * @return the marshalled object (as a Ruby hash) * @todo Handle gradients when christy gets the new gradient support added (23Dec08) */ VALUE Draw_marshal_dump(VALUE self) { Draw *draw; VALUE ddraw; Data_Get_Struct(self, Draw, draw); // Raise an exception if the Draw has a non-NULL gradient or element_reference field if (draw->info->element_reference.type != UndefinedReference || draw->info->gradient.type != UndefinedGradient) { rb_raise(rb_eTypeError, "can't dump gradient definition"); } ddraw = rb_hash_new(); // rb_hash_aset(ddraw, CSTR2SYM("primitive"), MAGICK_STRING_TO_OBJ(draw->info->primitive)); internal // rb_hash_aset(ddraw, CSTR2SYM("geometry"), MAGICK_STRING_TO_OBJ(draw->info->geometry)); set by "text" primitive // rb_hash_aset(ddraw, CSTR2SYM("viewbox"), Import_RectangleInfo(&draw->info->viewbox)); internal rb_hash_aset(ddraw, CSTR2SYM("affine"), Import_AffineMatrix(&draw->info->affine)); rb_hash_aset(ddraw, CSTR2SYM("gravity"), INT2FIX(draw->info->gravity)); rb_hash_aset(ddraw, CSTR2SYM("fill"), Pixel_from_PixelColor(&draw->info->fill)); rb_hash_aset(ddraw, CSTR2SYM("stroke"), Pixel_from_PixelColor(&draw->info->stroke)); rb_hash_aset(ddraw, CSTR2SYM("stroke_width"), rb_float_new(draw->info->stroke_width)); // rb_hash_aset(ddraw, CSTR2SYM("gradient"), Qnil); // not used yet rb_hash_aset(ddraw, CSTR2SYM("fill_pattern"), image_to_str(draw->info->fill_pattern)); rb_hash_aset(ddraw, CSTR2SYM("tile"), Qnil); // deprecated rb_hash_aset(ddraw, CSTR2SYM("stroke_pattern"), image_to_str(draw->info->stroke_pattern)); rb_hash_aset(ddraw, CSTR2SYM("stroke_antialias"), draw->info->stroke_antialias ? Qtrue : Qfalse); rb_hash_aset(ddraw, CSTR2SYM("text_antialias"), draw->info->text_antialias ? Qtrue : Qfalse); // rb_hash_aset(ddraw, CSTR2SYM("fill_rule"), INT2FIX(draw->info->fill_rule)); internal // rb_hash_aset(ddraw, CSTR2SYM("linecap"), INT2FIX(draw->info->linecap)); // rb_hash_aset(ddraw, CSTR2SYM("linejoin"), INT2FIX(draw->info->linejoin)); // rb_hash_aset(ddraw, CSTR2SYM("miterlimit"), ULONG2NUM(draw->info->miterlimit)); // rb_hash_aset(ddraw, CSTR2SYM("dash_offset"), rb_float_new(draw->info->dash_offset)); rb_hash_aset(ddraw, CSTR2SYM("decorate"), INT2FIX(draw->info->decorate)); // rb_hash_aset(ddraw, CSTR2SYM("compose"), INT2FIX(draw->info->compose)); set via "image" primitive // rb_hash_aset(ddraw, CSTR2SYM("text"), MAGICK_STRING_TO_OBJ(draw->info->text)); set via "text" primitive // rb_hash_aset(ddraw, CSTR2SYM("face"), Qnil); internal rb_hash_aset(ddraw, CSTR2SYM("font"), MAGICK_STRING_TO_OBJ(draw->info->font)); // rb_hash_aset(ddraw, CSTR2SYM("metrics"), Qnil); internal rb_hash_aset(ddraw, CSTR2SYM("family"), MAGICK_STRING_TO_OBJ(draw->info->family)); rb_hash_aset(ddraw, CSTR2SYM("style"), INT2FIX(draw->info->style)); rb_hash_aset(ddraw, CSTR2SYM("stretch"), INT2FIX(draw->info->stretch)); rb_hash_aset(ddraw, CSTR2SYM("weight"), ULONG2NUM(draw->info->weight)); rb_hash_aset(ddraw, CSTR2SYM("encoding"), MAGICK_STRING_TO_OBJ(draw->info->encoding)); rb_hash_aset(ddraw, CSTR2SYM("pointsize"), rb_float_new(draw->info->pointsize)); rb_hash_aset(ddraw, CSTR2SYM("density"), MAGICK_STRING_TO_OBJ(draw->info->density)); rb_hash_aset(ddraw, CSTR2SYM("align"), INT2FIX(draw->info->align)); rb_hash_aset(ddraw, CSTR2SYM("undercolor"), Pixel_from_PixelColor(&draw->info->undercolor)); // rb_hash_aset(ddraw, CSTR2SYM("border_color"), Pixel_from_PixelColor(&draw->info->border_color)); Montage and Polaroid // rb_hash_aset(ddraw, CSTR2SYM("server_name"), MAGICK_STRING_TO_OBJ(draw->info->server_name)); // rb_hash_aset(ddraw, CSTR2SYM("dash_pattern"), dash_pattern_to_array(draw->info->dash_pattern)); internal // rb_hash_aset(ddraw, CSTR2SYM("clip_mask"), MAGICK_STRING_TO_OBJ(draw->info->clip_mask)); internal // rb_hash_aset(ddraw, CSTR2SYM("bounds"), Import_SegmentInfo(&draw->info->bounds)); internal rb_hash_aset(ddraw, CSTR2SYM("clip_units"), INT2FIX(draw->info->clip_units)); rb_hash_aset(ddraw, CSTR2SYM("opacity"), QUANTUM2NUM(draw->info->opacity)); // rb_hash_aset(ddraw, CSTR2SYM("render"), draw->info->render ? Qtrue : Qfalse); internal // rb_hash_aset(ddraw, CSTR2SYM("element_reference"), Qnil); // not used yet // rb_hash_aset(ddraw, CSTR2SYM("debug"), draw->info->debug ? Qtrue : Qfalse); rb_hash_aset(ddraw, CSTR2SYM("kerning"), rb_float_new(draw->info->kerning)); rb_hash_aset(ddraw, CSTR2SYM("interword_spacing"), rb_float_new(draw->info->interword_spacing)); // Non-DrawInfo fields rb_hash_aset(ddraw, CSTR2SYM("primitives"), draw->primitives); // rb_hash_aset(ddraw, CSTR2SYM("shadow_color"), Pixel_from_PixelColor(&draw->shadow_color)); Polaroid-only return ddraw; }
VALUE addStrToHash(VALUE hash, const char* key, const char* val) { return rb_hash_aset(hash, rb_str_new2(key), rb_str_new2(val)); }
static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) { VALUE result = Qnil; if (ttype == TTYPE_BOOL) { result = mt->read_bool(protocol); } else if (ttype == TTYPE_BYTE) { result = mt->read_byte(protocol); } else if (ttype == TTYPE_I16) { result = mt->read_i16(protocol); } else if (ttype == TTYPE_I32) { result = mt->read_i32(protocol); } else if (ttype == TTYPE_I64) { result = mt->read_i64(protocol); } else if (ttype == TTYPE_STRING) { result = mt->read_string(protocol); } else if (ttype == TTYPE_DOUBLE) { result = mt->read_double(protocol); } else if (ttype == TTYPE_STRUCT) { VALUE klass = rb_hash_aref(field_info, class_sym); result = rb_class_new_instance(0, NULL, klass); rb_thrift_struct_read(result, protocol); } else if (ttype == TTYPE_MAP) { int i; VALUE map_header = mt->read_map_begin(protocol); int key_ttype = FIX2INT(rb_ary_entry(map_header, 0)); int value_ttype = FIX2INT(rb_ary_entry(map_header, 1)); int num_entries = FIX2INT(rb_ary_entry(map_header, 2)); VALUE key_info = rb_hash_aref(field_info, key_sym); VALUE value_info = rb_hash_aref(field_info, value_sym); result = rb_hash_new(); for (i = 0; i < num_entries; ++i) { VALUE key, val; key = read_anything(protocol, key_ttype, key_info); val = read_anything(protocol, value_ttype, value_info); rb_hash_aset(result, key, val); } mt->read_map_end(protocol); } else if (ttype == TTYPE_LIST) { int i; VALUE list_header = mt->read_list_begin(protocol); int element_ttype = FIX2INT(rb_ary_entry(list_header, 0)); int num_elements = FIX2INT(rb_ary_entry(list_header, 1)); result = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(result, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym))); } mt->read_list_end(protocol); } else if (ttype == TTYPE_SET) { VALUE items; int i; VALUE set_header = mt->read_set_begin(protocol); int element_ttype = FIX2INT(rb_ary_entry(set_header, 0)); int num_elements = FIX2INT(rb_ary_entry(set_header, 1)); items = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(items, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym))); } mt->read_set_end(protocol); result = rb_class_new_instance(1, &items, rb_cSet); } else { rb_raise(rb_eNotImpError, "read_anything not implemented for type %d!", ttype); } return result; }
VALUE addStrToHashLen(VALUE hash, const char* key, const char* val, int len) { return rb_hash_aset(hash, rb_str_new2(key), rb_str_new(val, len)); }
int init_parser(client_t *cli, const char *name, const short port) { VALUE object; char r_port[7]; cli->http = (http_parser*)ruby_xmalloc(sizeof(http_parser)); memset(cli->http, 0, sizeof(http_parser)); cli->environ = rb_hash_new(); rb_hash_aset(cli->environ, version_key, version_val); rb_hash_aset(cli->environ, scheme_key, scheme_val); rb_hash_aset(cli->environ, errors_key, errors_val); rb_hash_aset(cli->environ, multithread_key, multithread_val); rb_hash_aset(cli->environ, multiprocess_key, multiprocess_val); rb_hash_aset(cli->environ, run_once_key, run_once_val); rb_hash_aset(cli->environ, script_key, script_val); rb_hash_aset(cli->environ, server_name_key, server_name_val); rb_hash_aset(cli->environ, server_port_key, server_port_val); // query_string rb_hash_aset(cli->environ, query_string, empty_string); object = rb_str_new2(cli->remote_addr); rb_hash_aset(cli->environ, rb_remote_addr, object); sprintf(r_port, "%d", cli->remote_port); object = rb_str_new2(r_port); rb_hash_aset(cli->environ, rb_remote_port, object); http_parser_init(cli->http, HTTP_REQUEST); cli->http->data = cli; return 0; }
VALUE addHashToHash(VALUE hash, const char* key, VALUE val) { return rb_hash_aset(hash, rb_str_new2(key), val); }
/* call-seq: track_get_audio_channel_map() -> array Returns an array n-channels in length Array contains Hashes in the form: {:assignment => :description} where :description is a symbol representing an audio channel description. eg. :Left, :Right, :Mono */ static VALUE track_get_audio_channel_map(VALUE obj) { AudioChannelLayout *layout = track_get_audio_channel_layout(obj); if (layout == NULL) return Qnil; VALUE channels = Qnil; UInt32 numChannels, x, highLayoutTag; VALUE channel; char message[256]; AudioChannelLayoutTag layoutTag = layout->mChannelLayoutTag; if (layoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) { // using the descriptions // not implemented numChannels = layout->mNumberChannelDescriptions; channels = rb_ary_new2(numChannels); // loop through all channels, adding assignment descriptions AudioChannelDescription desc; char *trackStr; for (x=0; x < numChannels; x++) { desc = layout->mChannelDescriptions[x]; trackStr = track_str_for_AudioChannelLabel(desc.mChannelLabel); if (trackStr != NULL) { ADD_CHANNEL(channels, channel, trackStr); } else { // unsupported audio channel labels ADD_CHANNEL(channels, channel, "UnsupportedByRMov"); sprintf(message, "ChannelLabel unsupported by rmov: %d", (int)desc.mChannelLabel); rb_hash_aset(channel, ID2SYM(rb_intern("message")), rb_str_new2(message)); } } } else { numChannels = AudioChannelLayoutTag_GetNumberOfChannels(layoutTag); channels = rb_ary_new2(numChannels); if (layoutTag == kAudioChannelLayoutTag_UseChannelBitmap) { // use the bitmap approach // not implemented //rb_raise(eQuickTime, "Not Implemented: kAudioChannelLayoutTag_UseChannelBitmap in track_get_audio_channel_map"); for (x=0; x < numChannels; x++) { ADD_CHANNEL(channels, channel, "UnsupportedByRMov"); rb_hash_aset(channel, ID2SYM(rb_intern("message")), rb_str_new2("UseChannelBitmap unsupported by rmov")); } } else { // using a standard LayoutTag switch (layoutTag) { case kAudioChannelLayoutTag_Mono: ADD_CHANNEL(channels, channel, "Mono"); break; case kAudioChannelLayoutTag_Stereo: ADD_CHANNEL(channels, channel, "Left"); ADD_CHANNEL(channels, channel, "Right"); break; case kAudioChannelLayoutTag_MatrixStereo: ADD_CHANNEL(channels, channel, "LeftTotal"); ADD_CHANNEL(channels, channel, "RightTotal"); break; case kAudioChannelLayoutTag_SMPTE_DTV: ADD_CHANNEL(channels, channel, "Left"); ADD_CHANNEL(channels, channel, "Right"); ADD_CHANNEL(channels, channel, "Center"); ADD_CHANNEL(channels, channel, "LFEScreen"); ADD_CHANNEL(channels, channel, "LeftSurround"); ADD_CHANNEL(channels, channel, "RightSurround"); ADD_CHANNEL(channels, channel, "LeftTotal"); ADD_CHANNEL(channels, channel, "RightTotal"); break; default: // unsupported channels highLayoutTag = (layoutTag & 0xff0000) >> 16; sprintf(message, "layoutTag unsupported by rmov: (%dL << 16) | %d", (int)highLayoutTag, (int)numChannels); for (x=0; x < numChannels; x++) { ADD_CHANNEL(channels, channel, "UnsupportedByRMov"); rb_hash_aset(channel, ID2SYM(rb_intern("message")), rb_str_new2(message)); } //rb_raise(eQuickTime, "Unsupported ChannelLayoutTag in track_get_audio_channel_map: %d", layoutTag); break; } } } free(layout); return channels; }
/* @api private */ VALUE rb_do_self_organizing_map(int argc, VALUE *argv, VALUE self) { VALUE nx, ny, data, mask, weights, options; rb_scan_args(argc, argv, "31", &nx, &ny, &data, &options); if (TYPE(data) != T_ARRAY) rb_raise(rb_eArgError, "data should be an array of arrays"); mask = get_value_option(options, "mask", Qnil); if (!NIL_P(mask) && TYPE(mask) != T_ARRAY) rb_raise(rb_eArgError, "mask should be an array of arrays"); if (NIL_P(nx) || NUM2INT(rb_Integer(nx)) <= 0) rb_raise(rb_eArgError, "nx should be > 0"); if (NIL_P(ny) || NUM2INT(rb_Integer(ny)) <= 0) rb_raise(rb_eArgError, "ny should be > 0"); int nxgrid = NUM2INT(rb_Integer(nx)); int nygrid = NUM2INT(rb_Integer(ny)); int transpose = get_int_option(options, "transpose", 0); int npass = get_int_option(options, "iterations", DEFAULT_ITERATIONS); // e = euclidian, // b = city-block distance // c = correlation // a = absolute value of the correlation // u = uncentered correlation // x = absolute uncentered correlation // s = spearman's rank correlation // k = kendall's tau int dist = get_int_option(options, "metric", 'e'); double tau = get_dbl_option(options, "tau", 1.0); int i, j, k; int nrows = RARRAY_LEN(data); int ncols = RARRAY_LEN(rb_ary_entry(data, 0)); double **cdata = (double**)malloc(sizeof(double*)*nrows); int **cmask = (int **)malloc(sizeof(int *)*nrows); double *cweights = (double *)malloc(sizeof(double )*ncols); int **ccluster; double ***ccelldata; int dimx = nrows, dimy = ncols; if (transpose) { dimx = ncols; dimy = nrows; } ccluster = (int **)malloc(sizeof(int*)*dimx); for (i = 0; i < dimx; i++) ccluster[i] = (int*)malloc(sizeof(int)*2); for (i = 0; i < nrows; i++) { cdata[i] = (double*)malloc(sizeof(double)*ncols); cmask[i] = (int *)malloc(sizeof(int )*ncols); for (j = 0; j < ncols; j++) { cdata[i][j] = NUM2DBL(rb_Float(rb_ary_entry(rb_ary_entry(data, i), j))); cmask[i][j] = NIL_P(mask) ? 1 : NUM2INT(rb_Integer(rb_ary_entry(rb_ary_entry(mask, i), j))); } } weights = NIL_P(options) ? Qnil : rb_hash_aref(options, ID2SYM(rb_intern("weights"))); for (i = 0; i < ncols; i++) { cweights[i] = NIL_P(weights) ? 1.0 : NUM2DBL(rb_Float(rb_ary_entry(weights, i))); } ccelldata = (double***)malloc(sizeof(double**)*nxgrid); for (i = 0; i < nxgrid; i++) { ccelldata[i] = (double **)malloc(sizeof(double*)*nygrid); for (j = 0; j < nygrid; j++) ccelldata[i][j] = (double *)malloc(sizeof(double)*dimy); } somcluster(nrows, ncols, cdata, cmask, cweights, transpose, nxgrid, nygrid, tau, npass, dist, ccelldata, ccluster); VALUE result = rb_hash_new(); VALUE cluster = rb_ary_new(); VALUE centroid = rb_ary_new(); for (i = 0; i < dimx; i++) { VALUE gridpoint = rb_ary_new(); rb_ary_push(gridpoint, INT2NUM(ccluster[i][0])); rb_ary_push(gridpoint, INT2NUM(ccluster[i][1])); rb_ary_push(cluster, gridpoint); } for (i = 0; i < nxgrid; i++) { for (j = 0; j < nygrid; j++) { VALUE point = rb_ary_new(); for (k = 0; k < dimy; k++) rb_ary_push(point, DBL2NUM(ccelldata[i][j][k])); rb_ary_push(centroid, point); } } rb_hash_aset(result, ID2SYM(rb_intern("cluster")), cluster); rb_hash_aset(result, ID2SYM(rb_intern("centroid")), centroid); for (i = 0; i < nrows; i++) { free(cdata[i]); free(cmask[i]); } for (i = 0; i < dimx; i++) free(ccluster[i]); for (i = 0; i < nxgrid; i++) { for (j = 0; j < nygrid; j++) free(ccelldata[i][j]); free(ccelldata[i]); } free(cdata); free(cmask); free(ccelldata); free(cweights); free(ccluster); return result; }
static VALUE read_anything(VALUE protocol, field_metadata* fmd, protocol_method_table *pmt) { VALUE result = Qnil; if (fmd->type == TTYPE_BOOL) { result = fastcall_call(pmt->read_bool, protocol, Qnil); } else if (fmd->type == TTYPE_BYTE) { result = fastcall_call(pmt->read_byte, protocol, Qnil); } else if (fmd->type == TTYPE_I16) { result = fastcall_call(pmt->read_i16, protocol, Qnil); } else if (fmd->type == TTYPE_I32) { result = fastcall_call(pmt->read_i32, protocol, Qnil); } else if (fmd->type == TTYPE_I64) { result = fastcall_call(pmt->read_i64, protocol, Qnil); } else if (fmd->type == TTYPE_STRING) { result = fastcall_call(pmt->read_string, protocol, Qnil); } else if (fmd->type == TTYPE_DOUBLE) { result = fastcall_call(pmt->read_double, protocol, Qnil); } else if (fmd->type == TTYPE_STRUCT) { result = rb_class_new_instance(0, NULL, fmd->klass_v); if (rb_obj_is_kind_of(result, thrift_union_class)) { union_read(result, protocol, pmt); } else { struct_read(result, protocol, pmt); } } else if (fmd->type == TTYPE_MAP) { int i; VALUE map_header = fastcall_call(pmt->read_map_begin, protocol, Qnil); int key_ttype = FIX2INT(rb_ary_entry(map_header, 0)); int value_ttype = FIX2INT(rb_ary_entry(map_header, 1)); int num_entries = FIX2INT(rb_ary_entry(map_header, 2)); // Check the declared key and value types against the expected ones and skip the map contents // if the types don't match. field_metadata* key_md = fmd->key; field_metadata* value_md = fmd->value; if (key_md && value_md) { int specified_key_type = key_md->type; int specified_value_type = value_md->type; if (num_entries == 0 || (specified_key_type == key_ttype && specified_value_type == value_ttype)) { result = rb_hash_new(); for (i = 0; i < num_entries; ++i) { VALUE key, val; key = read_anything(protocol, key_md, pmt); val = read_anything(protocol, value_md, pmt); rb_hash_aset(result, key, val); } } else { skip_map_contents(protocol, INT2FIX(key_ttype), INT2FIX(value_ttype), num_entries); } } else { skip_map_contents(protocol, INT2FIX(key_ttype), INT2FIX(value_ttype), num_entries); } fastcall_call(pmt->read_map_end, protocol, Qnil); } else if (fmd->type == TTYPE_LIST) { int i; VALUE list_header = fastcall_call(pmt->read_list_begin, protocol, Qnil); int element_ttype = FIX2INT(rb_ary_entry(list_header, 0)); int num_elements = FIX2INT(rb_ary_entry(list_header, 1)); // Check the declared element type against the expected one and skip the list contents // if the types don't match. field_metadata* element_md = fmd->element; if (element_md) { int specified_element_type = element_md->type; if (specified_element_type == element_ttype) { result = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(result, read_anything(protocol, element_md, pmt)); } } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } fastcall_call(pmt->read_list_end, protocol, Qnil); } else if (fmd->type == TTYPE_SET) { VALUE items; int i; VALUE set_header = fastcall_call(pmt->read_set_begin, protocol, Qnil); int element_ttype = FIX2INT(rb_ary_entry(set_header, 0)); int num_elements = FIX2INT(rb_ary_entry(set_header, 1)); // Check the declared element type against the expected one and skip the set contents // if the types don't match. field_metadata* element_md = fmd->element; if (element_md) { int specified_element_type = element_md->type; if (specified_element_type == element_ttype) { items = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(items, read_anything(protocol, element_md, pmt)); } result = rb_class_new_instance(1, &items, rb_cSet); } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } fastcall_call(pmt->read_set_end, protocol, Qnil); } else { rb_raise(rb_eNotImpError, "read_anything not implemented for type %d!", fmd->type); } return result; }
/* @api private */ VALUE rb_do_treecluster(int argc, VALUE *argv, VALUE self) { VALUE size, data, mask, weights, options; rb_scan_args(argc, argv, "21", &size, &data, &options); if (TYPE(data) != T_ARRAY) rb_raise(rb_eArgError, "data should be an array of arrays"); mask = get_value_option(options, "mask", Qnil); if (!NIL_P(mask) && TYPE(mask) != T_ARRAY) rb_raise(rb_eArgError, "mask should be an array of arrays"); if (NIL_P(size) || NUM2INT(rb_Integer(size)) > RARRAY_LEN(data)) rb_raise(rb_eArgError, "size should be > 0 and <= data size"); int transpose = get_int_option(options, "transpose", 0); // s: pairwise single-linkage clustering // m: pairwise maximum- (or complete-) linkage clustering // a: pairwise average-linkage clustering // c: pairwise centroid-linkage clustering int method = get_int_option(options, "method", 'a'); // e = euclidian, // b = city-block distance // c = correlation // a = absolute value of the correlation // u = uncentered correlation // x = absolute uncentered correlation // s = spearman's rank correlation // k = kendall's tau int dist = get_int_option(options, "metric", 'e'); int i,j; int nrows = RARRAY_LEN(data); int ncols = RARRAY_LEN(rb_ary_entry(data, 0)); int nsets = NUM2INT(rb_Integer(size)); double **cdata = (double**)malloc(sizeof(double*)*nrows); int **cmask = (int **)malloc(sizeof(int *)*nrows); double *cweights = (double *)malloc(sizeof(double )*ncols); int *ccluster, dimx = nrows, dimy = ncols; for (i = 0; i < nrows; i++) { cdata[i] = (double*)malloc(sizeof(double)*ncols); cmask[i] = (int *)malloc(sizeof(int )*ncols); for (j = 0; j < ncols; j++) { cdata[i][j] = NUM2DBL(rb_Float(rb_ary_entry(rb_ary_entry(data, i), j))); cmask[i][j] = NIL_P(mask) ? 1 : NUM2INT(rb_Integer(rb_ary_entry(rb_ary_entry(mask, i), j))); } } weights = NIL_P(options) ? Qnil : rb_hash_aref(options, ID2SYM(rb_intern("weights"))); for (i = 0; i < ncols; i++) { cweights[i] = NIL_P(weights) ? 1.0 : NUM2DBL(rb_Float(rb_ary_entry(weights, i))); } if (transpose) { dimx = ncols; dimy = nrows; } ccluster = (int *)malloc(sizeof(int)*dimx); Node *tree = treecluster(nrows, ncols, cdata, cmask, cweights, transpose, dist, method, 0); VALUE result = Qnil, cluster; if (tree) { cuttree(dimx, tree, nsets, ccluster); result = rb_hash_new(); cluster = rb_ary_new(); for (i = 0; i < dimx; i++) rb_ary_push(cluster, INT2NUM(ccluster[i])); rb_hash_aset(result, ID2SYM(rb_intern("cluster")), cluster); } for (i = 0; i < nrows; i++) { free(cdata[i]); free(cmask[i]); } free(cdata); free(cmask); free(cweights); free(ccluster); if (tree) free(tree); else rb_raise(rb_eNoMemError, "treecluster ran out of memory"); return result; }
void init_ruby_class() { #if 0 // For documentation using YARD VALUE opencv = rb_define_module("OpenCV"); #endif if (rb_klass) return; VALUE opencv = rb_module_opencv(); rb_klass = rb_define_class_under(opencv, "CvFont", rb_cObject); rb_define_alloc_func(rb_klass, rb_allocate); VALUE face = rb_hash_new(); rb_define_const(rb_klass, "FACE", face); rb_hash_aset(face, ID2SYM(rb_intern("simplex")), INT2FIX(CV_FONT_HERSHEY_SIMPLEX)); rb_hash_aset(face, ID2SYM(rb_intern("plain")), INT2FIX(CV_FONT_HERSHEY_PLAIN)); rb_hash_aset(face, ID2SYM(rb_intern("duplex")), INT2FIX(CV_FONT_HERSHEY_DUPLEX)); rb_hash_aset(face, ID2SYM(rb_intern("triplex")), INT2FIX(CV_FONT_HERSHEY_TRIPLEX)); rb_hash_aset(face, ID2SYM(rb_intern("complex_small")), INT2FIX(CV_FONT_HERSHEY_COMPLEX_SMALL)); rb_hash_aset(face, ID2SYM(rb_intern("script_simplex")), INT2FIX(CV_FONT_HERSHEY_SCRIPT_SIMPLEX)); rb_hash_aset(face, ID2SYM(rb_intern("script_complex")), INT2FIX(CV_FONT_HERSHEY_SCRIPT_COMPLEX)); VALUE default_option = rb_hash_new(); rb_define_const(rb_klass, "FONT_OPTION", default_option); rb_hash_aset(default_option, ID2SYM(rb_intern("hscale")), rb_float_new(1.0)); rb_hash_aset(default_option, ID2SYM(rb_intern("vscale")), rb_float_new(1.0)); rb_hash_aset(default_option, ID2SYM(rb_intern("shear")), INT2FIX(0)); rb_hash_aset(default_option, ID2SYM(rb_intern("thickness")), INT2FIX(1)); rb_hash_aset(default_option, ID2SYM(rb_intern("line_type")), INT2FIX(8)); rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1); rb_define_method(rb_klass, "face", RUBY_METHOD_FUNC(rb_face), 0); rb_define_method(rb_klass, "hscale", RUBY_METHOD_FUNC(rb_hscale), 0); rb_define_method(rb_klass, "vscale", RUBY_METHOD_FUNC(rb_vscale), 0); rb_define_method(rb_klass, "shear", RUBY_METHOD_FUNC(rb_shear), 0); rb_define_method(rb_klass, "thickness", RUBY_METHOD_FUNC(rb_thickness), 0); rb_define_method(rb_klass, "line_type", RUBY_METHOD_FUNC(rb_line_type), 0); rb_define_method(rb_klass, "italic", RUBY_METHOD_FUNC(rb_italic), 0); }
/* call-seq: ox_default_options() => Hash * * Returns the default load and dump options as a Hash. The options are * - indent: [Fixnum] number of spaces to indent each element in an XML document * - trace: [Fixnum] trace level where 0 is silent * - encoding: [String] character encoding for the XML file * - with_dtd: [true|false|nil] include DTD in the dump * - with_instruct: [true|false|nil] include instructions in the dump * - with_xml: [true|false|nil] include XML prolog in the dump * - circular: [true|false|nil] support circular references while dumping * - xsd_date: [true|false|nil] use XSD date format instead of decimal format * - mode: [:object|:generic|:limited|nil] load method to use for XML * - effort: [:strict|:tolerant|:auto_define] set the tolerance level for loading * - symbolize_keys: [true|false|nil] symbolize element attribute keys or leave as Strings * @return [Hash] all current option settings. */ static VALUE get_def_opts(VALUE self) { VALUE opts = rb_hash_new(); int elen = (int)strlen(ox_default_options.encoding); rb_hash_aset(opts, ox_encoding_sym, (0 == elen) ? Qnil : rb_str_new(ox_default_options.encoding, elen)); rb_hash_aset(opts, indent_sym, INT2FIX(ox_default_options.indent)); rb_hash_aset(opts, trace_sym, INT2FIX(ox_default_options.trace)); rb_hash_aset(opts, with_dtd_sym, (Yes == ox_default_options.with_dtd) ? Qtrue : ((No == ox_default_options.with_dtd) ? Qfalse : Qnil)); rb_hash_aset(opts, with_xml_sym, (Yes == ox_default_options.with_xml) ? Qtrue : ((No == ox_default_options.with_xml) ? Qfalse : Qnil)); rb_hash_aset(opts, with_instruct_sym, (Yes == ox_default_options.with_instruct) ? Qtrue : ((No == ox_default_options.with_instruct) ? Qfalse : Qnil)); rb_hash_aset(opts, circular_sym, (Yes == ox_default_options.circular) ? Qtrue : ((No == ox_default_options.circular) ? Qfalse : Qnil)); rb_hash_aset(opts, xsd_date_sym, (Yes == ox_default_options.xsd_date) ? Qtrue : ((No == ox_default_options.xsd_date) ? Qfalse : Qnil)); rb_hash_aset(opts, symbolize_keys_sym, (Yes == ox_default_options.sym_keys) ? Qtrue : ((No == ox_default_options.sym_keys) ? Qfalse : Qnil)); switch (ox_default_options.mode) { case ObjMode: rb_hash_aset(opts, mode_sym, object_sym); break; case GenMode: rb_hash_aset(opts, mode_sym, generic_sym); break; case LimMode: rb_hash_aset(opts, mode_sym, limited_sym); break; case NoMode: default: rb_hash_aset(opts, mode_sym, Qnil); break; } switch (ox_default_options.effort) { case StrictEffort: rb_hash_aset(opts, effort_sym, strict_sym); break; case TolerantEffort: rb_hash_aset(opts, effort_sym, tolerant_sym); break; case AutoEffort: rb_hash_aset(opts, effort_sym, auto_define_sym); break; case NoEffort: default: rb_hash_aset(opts, effort_sym, Qnil); break; } return opts; }