Exemple #1
0
void
define_ruby_class()
{
  if(rb_klass)
    return;
  /* 
   * opencv = rb_define_module("OpenCV");
   * cvpoint2d32f = rb_define_class_under(opencv, "CvPoint2D32f", rb_cObject);
   *
   * note: this comment is used by rdoc.
   */
  VALUE opencv = rb_module_opencv();
  VALUE cvpoint2d32f = cCvPoint2D32f::rb_class();
  rb_klass = rb_define_class_under(opencv, "CvPoint3D32f", cvpoint2d32f);
  rb_define_alloc_func(rb_klass, rb_allocate);
  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
  rb_define_method(rb_klass, "z", RUBY_METHOD_FUNC(rb_z), 0);
  rb_define_method(rb_klass, "z=", RUBY_METHOD_FUNC(rb_set_z), 1);

  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
}
Exemple #2
0
void Init_blake2_ext() {
  cBlake2 = rb_define_class("Blake2", rb_cObject);
  rb_define_alloc_func(cBlake2, blake2_alloc);

  rb_define_private_method(cBlake2, "initialize", RUBY_METHOD_FUNC(m_blake2_initialize), 2);
  rb_define_method(cBlake2, "digest", RUBY_METHOD_FUNC(m_blake2_digest), 2);
}
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, "CvHuMoments", rb_cObject);
  rb_define_alloc_func(rb_klass, rb_allocate);
  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 1);
  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
  rb_define_alias(rb_klass, "to_a", "to_ary");
  
  DEFINE_CVHUMOMENTS_GETTER(hu1);
  DEFINE_CVHUMOMENTS_GETTER(hu2);
  DEFINE_CVHUMOMENTS_GETTER(hu3);
  DEFINE_CVHUMOMENTS_GETTER(hu4);
  DEFINE_CVHUMOMENTS_GETTER(hu5);
  DEFINE_CVHUMOMENTS_GETTER(hu6);
  DEFINE_CVHUMOMENTS_GETTER(hu7);
}
Exemple #4
0
void
wdm_rb_monitor_init()
{
    WDM_DEBUG("Registering WDM::Monitor with Ruby!");

    wdm_rb_sym_call = rb_intern("call");
    wdm_rb_sym_files = rb_intern("files");
    wdm_rb_sym_directories = rb_intern("directories");
    wdm_rb_sym_attributes = rb_intern("attributes");
    wdm_rb_sym_size = rb_intern("size");
    wdm_rb_sym_last_write = rb_intern("last_write");
    wdm_rb_sym_last_access = rb_intern("last_access");
    wdm_rb_sym_creation = rb_intern("creation");
    wdm_rb_sym_security = rb_intern("security");
    wdm_rb_sym_default = rb_intern("default");

    eWDM_MonitorRunningError = rb_define_class_under(mWDM, "MonitorRunningError", eWDM_Error);
    eWDM_InvalidDirectoryError = rb_define_class_under(mWDM, "InvalidDirectoryError", eWDM_Error);
    eWDM_UnknownFlagError = rb_define_class_under(mWDM, "UnknownFlagError", eWDM_Error);
    eWDM_UnwatchableDirectoryError = rb_define_class_under(mWDM, "UnwatchableDirectoryError", eWDM_Error);

    cWDM_Monitor = rb_define_class_under(mWDM, "Monitor", rb_cObject);

    rb_define_alloc_func(cWDM_Monitor, rb_monitor_alloc);
    rb_define_method(cWDM_Monitor, "watch", RUBY_METHOD_FUNC(rb_monitor_watch), -1);
    rb_define_method(cWDM_Monitor, "watch_recursively", RUBY_METHOD_FUNC(rb_monitor_watch_recursively), -1);
    rb_define_method(cWDM_Monitor, "run!", RUBY_METHOD_FUNC(rb_monitor_run_bang), 0);
    rb_define_method(cWDM_Monitor, "stop", RUBY_METHOD_FUNC(rb_monitor_stop), 0);
}
Exemple #5
0
/**
 * require時に呼び出し
 */
extern "C" void Init_hello()
{
  VALUE c = rb_define_class("Hello", rb_cObject);

  rb_define_alloc_func(c, wrap_Hello_alloc);
  rb_define_private_method(c, "initialize", RUBY_METHOD_FUNC(wrap_Hello_init), 0);
  rb_define_method(c, "say_hello", RUBY_METHOD_FUNC(wrap_Hello_sayHello), 0);
}
Exemple #6
0
// init
void init_IdMapDb()
{
    cIdMapDb = rb_define_class_under(GettextpoHelper, "IdMapDb", rb_cObject);
    rb_define_singleton_method(cIdMapDb, "new", RUBY_METHOD_FUNC(cIdMapDb_new), 1);
    rb_define_method(cIdMapDb, "create", RUBY_METHOD_FUNC(cIdMapDb_create), 1);
    rb_define_method(cIdMapDb, "normalize_database", RUBY_METHOD_FUNC(cIdMapDb_normalize_database), 0);
    rb_define_method(cIdMapDb, "get_min_id", RUBY_METHOD_FUNC(cIdMapDb_get_min_id), 1);
    rb_define_method(cIdMapDb, "get_min_id_array", RUBY_METHOD_FUNC(cIdMapDb_get_min_id_array), 2);
}
Exemple #7
0
WindowBindings::WindowBindings()
: RubyBindings<Window, false>(
    rb_define_class("MHWindow", rb_cObject),
    "WindowBindings")
{
	rb_define_method(_class, "ratio",  RUBY_METHOD_FUNC(WindowBindings::Ratio), 0);
	rb_define_method(_class, "width",  RUBY_METHOD_FUNC(WindowBindings::Width), 0);
	rb_define_method(_class, "height", RUBY_METHOD_FUNC(WindowBindings::Height), 0);
}
Exemple #8
0
void Initialize()
{
    rb_mStorage = rb_define_module_under(rb_mJubatus, "Storage");
    rb_cBasicStorage = rb_define_class_under(rb_mStorage, "BasicStorage", rb_cObject);

    rb_define_alloc_func(rb_cBasicStorage, storage_alloc);
    rb_define_method(rb_cBasicStorage, "initialize", RUBY_METHOD_FUNC(storage_init), 0);
    rb_define_method(rb_cBasicStorage, "type", RUBY_METHOD_FUNC(storage_type), 0);
}
Exemple #9
0
void Init_sort() {
  VALUE c = rb_define_class("Sort", rb_cObject);

  rb_define_alloc_func(c, wrap_Sort_alloc);
  rb_define_private_method(c, "initialize", RUBY_METHOD_FUNC(wrap_Sort_init), 1);
  rb_define_method(c, "inspect", RUBY_METHOD_FUNC(wrap_Sort_toString), 0);
  rb_define_method(c, "to_s", RUBY_METHOD_FUNC(wrap_Sort_toString), 0);
  rb_define_method(c, "greet", RUBY_METHOD_FUNC(wrap_Sort_greet), 0);
  rb_define_method(c, "values", RUBY_METHOD_FUNC(wrap_Sort_getValues), 0);
}
Exemple #10
0
void
define_ruby_class()
{
  if (rb_klass)
    return;
  /* 
   * opencv = rb_define_module("OpenCV");
   * cvmat = rb_define_class_under(opencv, "CvMat", rb_cObject);
   *
   * note: this comment is used by rdoc.
   */
  VALUE opencv = rb_module_opencv();
  VALUE cvmat = cCvMat::rb_class();
  rb_klass = rb_define_class_under(opencv, "IplImage", cvmat);
  rb_define_alloc_func(rb_klass, rb_allocate);
  rb_define_singleton_method(rb_klass, "load", RUBY_METHOD_FUNC(rb_load_image), -1);
  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1); 
  rb_define_method(rb_klass, "get_roi", RUBY_METHOD_FUNC(rb_get_roi), 0);
  rb_define_alias(rb_klass, "roi", "get_roi");
  rb_define_method(rb_klass, "set_roi", RUBY_METHOD_FUNC(rb_set_roi), 1);
  rb_define_alias(rb_klass, "roi=", "set_roi");
  rb_define_method(rb_klass, "reset_roi", RUBY_METHOD_FUNC(rb_reset_roi), 0);
  rb_define_method(rb_klass, "get_coi", RUBY_METHOD_FUNC(rb_get_coi), 0);
  rb_define_alias(rb_klass, "coi", "get_coi");
  rb_define_method(rb_klass, "set_coi", RUBY_METHOD_FUNC(rb_set_coi), 1);
  rb_define_alias(rb_klass, "coi=", "set_coi");
  rb_define_method(rb_klass, "reset_coi", RUBY_METHOD_FUNC(rb_reset_coi), 0); 

  rb_define_method(rb_klass, "smoothness", RUBY_METHOD_FUNC(rb_smoothness), -1);
}
Exemple #11
0
void Init_sash() {
    VALUE mSash = rb_define_module("Sash");
    rb_define_singleton_method(mSash, "digest", RUBY_METHOD_FUNC(rb_digest), -1);
    rb_define_singleton_method(mSash, "base64", RUBY_METHOD_FUNC(rb_base64), -1);

    rb_define_const(mSash, "METHOD_SDBM", INT2FIX(0));
    rb_define_const(mSash, "METHOD_DJB2", INT2FIX(1));

    sMethod = ID2SYM(rb_intern("method"));
    rb_gc_mark(sMethod);
}
Exemple #12
0
// The initialization method for this module
void Init_ruby_bluetooth()
{
    bt_module = rb_define_module("Bluetooth");
    bt_device_class = rb_define_class_under(bt_module, "Device", rb_cObject);
    bt_devices_class = rb_define_class_under(bt_module, "Devices", rb_cObject);
    rb_define_singleton_method(bt_devices_class, "scan", RUBY_METHOD_FUNC(bt_devices_scan), 0);
    rb_define_method(bt_device_class, "initialize", RUBY_METHOD_FUNC(bt_device_new), 2);
    rb_define_attr(bt_device_class, "addr", Qtrue, Qfalse);
    rb_define_attr(bt_device_class, "name", Qtrue, Qfalse);
    rb_undef_method(bt_devices_class, "initialize");
}
Exemple #13
0
/*
 * call-seq:
 *   == image -> bool
 *
 * compares two image.
 *
 *
 */
DLL_LOCAL VALUE _equal(VALUE self, VALUE other)
{
	equal_obj obj;
	obj.self = _self;
	obj.other = other;

	return rb_rescue(
		RUBY_METHOD_FUNC(_equal_block),(VALUE)&obj,
		RUBY_METHOD_FUNC(_equal_rescue),Qnil
	);
}
Exemple #14
0
  void Init_client () {

    mysql_module = rb_define_module("MySQL");
    binlog_class = rb_define_class_under(mysql_module, "Binlog", rb_cObject);
    client_class = rb_define_class_under(binlog_class, "Client", rb_cObject);

    rb_define_private_method (client_class, "initialize", RUBY_METHOD_FUNC(mysql_binlog_client_initialize), 1);
    rb_define_method(client_class, "connect", RUBY_METHOD_FUNC(mysql_binlog_client_connect), 0);
    rb_define_method(client_class, "set_position", RUBY_METHOD_FUNC(mysql_binlog_client_set_position), 1);
    rb_define_method(client_class, "get_position", RUBY_METHOD_FUNC(mysql_binlog_client_get_position), 0);
    rb_define_method(client_class, "wait_for_next_event", RUBY_METHOD_FUNC(mysql_binlog_client_wait_for_next_event), 0);
  }
Exemple #15
0
extern "C" void Init_bayeux_sioux()
{
    const VALUE mod_sioux = rb_define_module_under( rb_define_module( "Rack" ), "Sioux" );
    VALUE class_    = rb_define_class_under( mod_sioux, "SiouxBayeuxImplementation", rb_cObject );

    rb_define_alloc_func( class_, alloc_bayeux );
    rb_define_method( class_, "run", RUBY_METHOD_FUNC( run_bayeux ), 2 );
    rb_define_method( class_, "[]=", RUBY_METHOD_FUNC( update_node_bayeux ), 2 );
    rb_define_method( class_, "subscribe_for_testing", RUBY_METHOD_FUNC( subscribe_bayeux ), 1 );

    Init_pubsub_sioux();
}
void Init_OgreMovableObjectListener(VALUE rb_mOgre)
{
#if 0
	rb_mOgre = rb_define_module("Ogre");
	rb_mOgreMovableObject = rb_define_module_under(rb_mOgre,"MovableObject");
#endif
	rb_mOgreMovableObjectListener = rb_define_module_under(rb_mOgreMovableObject,"Listener");

	rb_define_method(rb_mOgreMovableObjectListener,"object_destroyed",RUBY_METHOD_FUNC(Ogre_dummy1),1);// in ogre.y
	rb_define_method(rb_mOgreMovableObjectListener,"object_attached",RUBY_METHOD_FUNC(Ogre_dummy1),1);// in ogre.y
	rb_define_method(rb_mOgreMovableObjectListener,"object_detached",RUBY_METHOD_FUNC(Ogre_dummy1),1);// in ogre.y
	rb_define_method(rb_mOgreMovableObjectListener,"object_moved",RUBY_METHOD_FUNC(Ogre_dummy1),1);// in ogre.y
}
Exemple #17
0
void
rb_define_fs_node(){
    
    rb_cNode = rb_define_class("FSNode", rb_cObject);
    rb_define_alloc_func(rb_cNode, wrap_Node_allocate);
    rb_define_attr(rb_cNode, "server", 1, 1);
    rb_define_method(rb_cNode, "initialize", RUBY_METHOD_FUNC(rb_Node_initialize), -1);
    rb_define_method(rb_cNode, "send_pack", RUBY_METHOD_FUNC(rb_Node_send_pack), 1);
    rb_define_method(rb_cNode, "close", RUBY_METHOD_FUNC(rb_Node_close), 0);
    rb_define_method(rb_cNode, "active", RUBY_METHOD_FUNC(rb_Node_active), 0);
    rb_define_method(rb_cNode, "id", RUBY_METHOD_FUNC(rb_Node_id), 0);
    
}
Exemple #18
0
	VALUE RubyUtils::KListToRubyValue(SharedValue obj)
	{
		// Lazily initialize the KMethod wrapper class
		if (KListClass == Qnil)
		{
			KListClass = rb_define_class("RubyKList", rb_cObject);
			rb_define_method(KListClass, "method_missing",
				RUBY_METHOD_FUNC(RubyKObjectMethodMissing), -1);
			rb_define_method(KListClass, "method",
				RUBY_METHOD_FUNC(RubyKObjectMethod), -1);
			rb_define_method(KListClass, "methods",
				RUBY_METHOD_FUNC(RubyKObjectMethods), 0);
			rb_define_method(KListClass, "respond_to?",
				RUBY_METHOD_FUNC(RubyKObjectRespondTo), -1);
			rb_define_method(KListClass, "[]",
				RUBY_METHOD_FUNC(RubyKListGetElt), -1);
			rb_define_method(KListClass, "[]=",
				RUBY_METHOD_FUNC(RubyKListSetElt), -1);
			rb_define_method(KListClass, "length",
				RUBY_METHOD_FUNC(RubyKListLength), -1);
			rb_define_method(KListClass, "each",
				RUBY_METHOD_FUNC(RubyKListEach), 0);
		}

		VALUE wrapper = Data_Wrap_Struct(KListClass, 0, RubyKObjectFree, new SharedValue(obj));
		rb_obj_call_init(wrapper, 0, 0);
		return wrapper;
	}
Exemple #19
0
void
init_ruby_class()
{
#if 0
  // For documentation using YARD
  VALUE opencv = rb_define_module("OpenCV");
#endif

  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, "CvPoint", rb_cObject);
  rb_define_alloc_func(rb_klass, rb_allocate);
  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);

  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
  rb_define_alias(rb_klass, "to_a", "to_ary");
}
void Init_CeguiDefaultResourceProvider(VALUE rb_mCegui)
{
#if 0
	rb_mCegui = rb_define_module("CEGUI");
	
	rb_cCeguiResourceProvider = rb_define_class_under(rb_mCegui,"ResourceProvider",rb_cObject);
#endif
	rb_cCeguiDefaultResourceProvider = rb_define_class_under(rb_mCegui,"DefaultResourceProvider",rb_cCeguiResourceProvider);
	
	rb_define_alloc_func(rb_cCeguiDefaultResourceProvider,CeguiDefaultResourceProvider_alloc);

	rb_define_method(rb_cCeguiDefaultResourceProvider,"[]",RUBY_METHOD_FUNC(CeguiDefaultResourceProvider_get),1);
	rb_define_method(rb_cCeguiDefaultResourceProvider,"[]=",RUBY_METHOD_FUNC(CeguiDefaultResourceProvider_set),2);
}
void Init_fuzzy_string() {
    mFuzzy = rb_define_module("FuzzyString");

    fuzzy_default_language = rb_str_new2("en");
    rb_global_variable(&fuzzy_default_language);

    rb_define_module_function(mFuzzy, "jaro_winkler_distance", RUBY_METHOD_FUNC(fuzzy_jaro_winkler_distance), 2);
    rb_define_module_function(mFuzzy, "levenstein_distance", RUBY_METHOD_FUNC(fuzzy_levenstein_distance), 2);
    rb_define_module_function(mFuzzy, "stem", RUBY_METHOD_FUNC(fuzzy_snowball), -1);
    rb_define_module_function(mFuzzy, "stem_languages", RUBY_METHOD_FUNC(fuzzy_snowball_languages), 0);
    rb_define_module_function(mFuzzy, "soundex", RUBY_METHOD_FUNC(fuzzy_soundex), 1);

    rb_define_const(mFuzzy, "VERSION", rb_str_new2(RUBY_FUZZY_VERSION));
}
Exemple #22
0
void Init_melbourne(void) {
  VALUE rb_cMelbourne;

  melbourne::init_symbols();

#ifndef RUBINIUS
  VALUE rb_mRubinius = rb_const_get(rb_cObject, rb_intern("Rubinius"));
#endif

  rb_cMelbourne = rb_define_class_under(rb_mRubinius, "Melbourne", rb_cObject);
  rb_define_method(rb_cMelbourne, "string_to_ast",
      RUBY_METHOD_FUNC(melbourne_string_to_ast), 3);
  rb_define_method(rb_cMelbourne, "file_to_ast",
      RUBY_METHOD_FUNC(melbourne_file_to_ast), 2);
}
Exemple #23
0
static VALUE rb_keychain_add_password(VALUE self, VALUE kind, VALUE options){
  SecKeychainRef keychain=NULL;
  Data_Get_Struct(self, struct OpaqueSecKeychainRef, keychain);

  Check_Type(options, T_HASH);
  Check_Type(kind, T_STRING);


  CFMutableDictionaryRef attributes = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
  rb_add_value_to_cf_dictionary(attributes, kSecClass, kind);
  CFDictionarySetValue(attributes, kSecReturnAttributes, kCFBooleanTrue);
  CFDictionarySetValue(attributes, kSecReturnRef, kCFBooleanTrue);
  CFDictionarySetValue(attributes, kSecUseKeychain, keychain);

  VALUE rAttributes = Data_Wrap_Struct(rb_cPointerWrapper, NULL, NULL, attributes);

  rb_block_call(options, rb_intern("each"), 0, NULL, RUBY_METHOD_FUNC(add_conditions_to_query), (VALUE)rAttributes);

  CFDictionaryRef result;

  OSStatus status = SecItemAdd(attributes, (CFTypeRef*)&result);
  CFRelease(attributes);
  CheckOSStatusOrRaise(status);

  VALUE rb_keychain_item = rb_keychain_item_from_sec_dictionary(result);
  CFRelease(result);
  return rb_keychain_item;
}
void register_math(VALUE rb_mlemon) {
   
   rb_define_const(rb_mlemon, "E", DBL2NUM(lemon::E));
   rb_define_const(rb_mlemon, "LOG2E", DBL2NUM(lemon::LOG2E));
   rb_define_const(rb_mlemon, "LOG10E", DBL2NUM(lemon::LOG10E));
   rb_define_const(rb_mlemon, "LN2", DBL2NUM(lemon::LN2));
   rb_define_const(rb_mlemon, "LN10", DBL2NUM(lemon::LN10));
   rb_define_const(rb_mlemon, "PI", DBL2NUM(lemon::PI));
   rb_define_const(rb_mlemon, "PI_2", DBL2NUM(lemon::PI_2));
   rb_define_const(rb_mlemon, "PI_4", DBL2NUM(lemon::PI_4));
   rb_define_const(rb_mlemon, "SQRT2", DBL2NUM(lemon::SQRT2));
   rb_define_const(rb_mlemon, "SQRT1_2", DBL2NUM(lemon::SQRT1_2));  

   rb_define_module_function(rb_mlemon, "round", RUBY_METHOD_FUNC(wrap_round), 1);
   rb_define_module_function(rb_mlemon, "is_nan", RUBY_METHOD_FUNC(wrap_isNan), 1);
}
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, "CvHaarClassifierCascade", rb_cObject);
  rb_define_alloc_func(rb_klass, rb_allocate);
  rb_define_singleton_method(rb_klass, "load", RUBY_METHOD_FUNC(rb_load), 1);
  rb_define_method(rb_klass, "detect_objects", RUBY_METHOD_FUNC(rb_detect_objects), -1);
}
Exemple #26
0
RenderableBindings::RenderableBindings()
: RubyBindings<Renderable, true>(
	rb_define_class("Renderable", rb_cObject),
	"RenderableBindings")
{
    rb_define_method(_class, "set_translation_matrix", RUBY_METHOD_FUNC(RenderableBindings::SetTranslationMatrix), 3);
}
Exemple #27
0
static VALUE rb_keychain_item_save(VALUE self){
  SecKeychainItemRef keychainItem = NULL;
  Data_Get_Struct(self, struct OpaqueSecKeychainItemRef, keychainItem);

  CFMutableDictionaryRef query = sec_query_identifying_item(keychainItem);

  CFMutableDictionaryRef attributes = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
  VALUE rb_attributes = rb_ivar_get(self, rb_intern("@attributes"));

  VALUE attributes_wrapper = Data_Wrap_Struct(rb_cPointerWrapper, NULL, NULL, attributes);

  rb_block_call(rb_attributes, rb_intern("each"), 0, NULL, RUBY_METHOD_FUNC(copy_attributes_for_update), (VALUE)attributes_wrapper);

  VALUE newPassword = rb_ivar_get(self, rb_intern("@unsaved_password"));
  if(!NIL_P(newPassword)){
    rb_add_value_to_cf_dictionary(attributes, kSecValueData, newPassword);
  }
  CFStringRef cfclass = rb_copy_item_class(keychainItem);
  CFDictionarySetValue(query, kSecClass, cfclass);
  CFRelease(cfclass);
  
  OSStatus result = SecItemUpdate(query, attributes);

  CFRelease(query);
  CFRelease(attributes);
  CheckOSStatusOrRaise(result);
  rb_keychain_item_reload(self);
  return self;
}
Exemple #28
0
void
Init_rtMidiWrapper()
{
	rb_rtMidiWrapper = rb_define_module("RtMidiLib");
	rb_rtMidiIn = rb_define_class_under(rb_rtMidiWrapper, "MidiInDevice", rb_cObject);
	rb_define_alloc_func(rb_rtMidiIn, rtMidiIn_allocate);
	rb_define_method(rb_rtMidiIn, "getNumDevices", RUBY_METHOD_FUNC(rtMidiIn_getNumDevices), 0);
	 
	rb_define_method(rb_rtMidiIn, "getDeviceNames", RUBY_METHOD_FUNC(rtMidiIn_getDeviceNames), 0);
	rb_define_method(rb_rtMidiIn, "connect", RUBY_METHOD_FUNC(rtMidiIn_connect), 1);
	//rb_define_method(rb_rtMidiIn, "disconnect", RUBY_METHOD_FUNC(rtMidiIn_disconnect), 0);
	rb_define_method(rb_rtMidiIn, "getData", RUBY_METHOD_FUNC(rtMidiIn_getData), 0);
		
	// later possibly support MidiOut
	//rb_rtMidiOut = rb_define_class_under(rb_rtMidiWrapper, "MidiOutDevice", rb_cObject);
}
Exemple #29
0
/*
 * call-seq:
 *   each_child -> Enumerator
 *   each_child { |child| } -> self
 *
 * iterates the children in this property.
 * ===Return value
 * self
 *
*/
DLL_LOCAL VALUE _each_child(VALUE self)
{
    RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_each_child_size));
    std::size_t count = _self->GetChildCount();
    for(std::size_t i = 0; i < count; ++i)
        rb_yield(wrap(_self->Item(i)));
    return self;
}
 void Init_fast_containers() {
   FastContainers = rb_define_module("FastContainers");
   PriorityQueue = rb_define_class_under(FastContainers, "PriorityQueue", rb_cObject);
   rb_global_variable(&FastContainers);
   rb_global_variable(&PriorityQueue);
   
   rb_define_singleton_method(PriorityQueue, "new", RUBY_METHOD_FUNC(pq_new), 1);
   rb_define_method(PriorityQueue, "size",     RUBY_METHOD_FUNC(pq_size), 0);
   rb_define_method(PriorityQueue, "push",     RUBY_METHOD_FUNC(pq_push), 2);
   rb_define_method(PriorityQueue, "top",      RUBY_METHOD_FUNC(pq_top), 0);
   rb_define_method(PriorityQueue, "top_key",  RUBY_METHOD_FUNC(pq_top_key), 0);
   rb_define_method(PriorityQueue, "second_best_key", RUBY_METHOD_FUNC(pq_second_best_key), 0);
   rb_define_method(PriorityQueue, "pop",      RUBY_METHOD_FUNC(pq_pop), 0);
   rb_define_method(PriorityQueue, "empty?",    RUBY_METHOD_FUNC(pq_empty), 0);
   rb_define_method(PriorityQueue, "each",     RUBY_METHOD_FUNC(pq_each), 0);
   rb_define_method(PriorityQueue, "pop_each", RUBY_METHOD_FUNC(pq_pop_each), 0);
 }