C++ rb_undef_method函数代码示例

void
Init_gtk_table(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TABLE, "Table", mGtk);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(resize, 2);
    RG_DEF_METHOD(attach, -1);
    RG_DEF_METHOD(attach_defaults, 5);
    G_REPLACE_SET_PROPERTY(RG_TARGET_NAMESPACE, "row_spacing", tbl_set_row_spacing, 2);
    rb_undef_method(RG_TARGET_NAMESPACE, "row_spacing=");
    G_REPLACE_SET_PROPERTY(RG_TARGET_NAMESPACE, "column_spacing", tbl_set_col_spacing, 2);
    rb_undef_method(RG_TARGET_NAMESPACE, "column_spacing=");
    RG_DEF_METHOD(get_row_spacing, 1);
    rb_undef_method(RG_TARGET_NAMESPACE, "row_spacing");
    RG_DEF_METHOD(get_column_spacing, 1);
    rb_undef_method(RG_TARGET_NAMESPACE, "column_spacing");
    RG_DEF_METHOD(set_row_spacings, 1);
    RG_DEF_METHOD(set_column_spacings, 1);
/* deprecated
    RG_DEF_METHOD(row_spacings, 0);
    RG_DEF_METHOD(column_spacings, 0);
*/
    RG_DEF_METHOD(default_row_spacing, 0);
    RG_DEF_METHOD(default_column_spacing, 0);
    RG_DEF_METHOD(size, 0);
}

void
Init_rpm_spec(void)
{
	rpm_cSpec = rb_define_class_under(rpm_mRPM, "Spec", rb_cData);
	rb_define_singleton_method(rpm_cSpec, "open", spec_s_open, 1);
	rb_define_singleton_method(rpm_cSpec, "new", spec_s_open, 1);
	rb_define_method(rpm_cSpec, "buildroot", rpm_spec_get_buildroot, 0);
	rb_define_method(rpm_cSpec, "buildsubdir", rpm_spec_get_buildsubdir, 0);
	rb_define_method(rpm_cSpec, "buildarchs", rpm_spec_get_buildarchs, 0);
	rb_define_method(rpm_cSpec, "buildrequires", rpm_spec_get_buildrequires, 0);
	rb_define_method(rpm_cSpec, "buildconflicts", rpm_spec_get_buildconflicts, 0);
	rb_define_method(rpm_cSpec, "build_restrictions", rpm_spec_get_build_restrictions, 0);
	rb_define_method(rpm_cSpec, "sources", rpm_spec_get_sources, 0);
	rb_define_method(rpm_cSpec, "packages", rpm_spec_get_packages, 0);
	rb_define_method(rpm_cSpec, "build", rpm_spec_build, -1);
	rb_define_method(rpm_cSpec, "expand_macros", rpm_spec_expand_macros, 1);
	rb_undef_method(rpm_cSpec, "dup");
	rb_undef_method(rpm_cSpec, "clone");

	id_ba = rb_intern("buildarchs");
	id_br = rb_intern("buildrequires");
	id_bc = rb_intern("buildconflicts");
	id_src = rb_intern("sources");
	id_pkg = rb_intern("packages");
	id_rest = rb_intern("build_restrictions");
}

void Init_minisat()
{
    rb_mMiniSat = rb_define_module("MiniSat");

    rb_cSolver = rb_define_class_under(rb_mMiniSat, "Solver", rb_cObject);
    rb_define_alloc_func(rb_cSolver, solver_alloc);
    rb_define_method(rb_cSolver, "new_var", solver_new_var, 0);
    rb_define_method(rb_cSolver, "add_clause", solver_add_clause, -1);
    rb_define_method(rb_cSolver, "<<", solver_add_clause_2, 1);
    rb_define_method(rb_cSolver, "[]", solver_ref_var, 1);
    rb_define_method(rb_cSolver, "solve", solver_solve, -1);
    rb_define_method(rb_cSolver, "simplify", solver_simplify, 0);
    rb_define_method(rb_cSolver, "simplify_db", solver_simplify_db, 0);
    rb_define_method(rb_cSolver, "var_size", solver_var_size, 0);
    rb_define_method(rb_cSolver, "clause_size", solver_clause_size, 0);
    rb_define_method(rb_cSolver, "to_s", solver_to_s, 0);
    rb_define_method(rb_cSolver, "solved?", solver_solved_p, 0);
    rb_define_method(rb_cSolver, "satisfied?", solver_satisfied_p, 0);

    rb_cVariable = rb_define_class_under(rb_mMiniSat, "Variable", rb_cObject);
    rb_undef_method(CLASS_OF(rb_cVariable), "new");
    rb_define_method(rb_cVariable, "[email protected]", variable_pos, 0);
    rb_define_method(rb_cVariable, "[email protected]", variable_neg, 0);
    rb_define_method(rb_cVariable, "value", variable_value, 0);

    rb_cLiteral = rb_define_class_under(rb_mMiniSat, "Literal", rb_cObject);
    rb_undef_method(CLASS_OF(rb_cLiteral), "new");
}

void 
Init_gtk_handle_box(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_HANDLE_BOX, "HandleBox", mGtk);

    RG_DEF_METHOD(initialize, 0);
    rb_undef_method(RG_TARGET_NAMESPACE, "shadow");
    rb_undef_method(RG_TARGET_NAMESPACE, "shadow=");
    rb_undef_method(RG_TARGET_NAMESPACE, "set_shadow");
}

void Init_wkhtml_native() {
  //Global initialization of library and when Ruby shuts down
  wkhtmltopdf_init(USE_GRAPHICS_INT);
  wkhtmltoimage_init(USE_GRAPHICS_INT);
  rb_set_end_proc(Deinit_wkhtml_native, Qnil);

  idReady = rb_intern("ready");

  mWkHtml = rb_define_module("WkHtml");
  rb_define_const(mWkHtml, "LIBRARY_VERSION", rb_obj_freeze(rb_str_new_cstr(wkhtmltopdf_version())));
  rb_define_const(mWkHtml, "USE_GRAPHICS", INT2BOOL(USE_GRAPHICS_INT));

  mWkHtmlToPdf = rb_define_module_under(mWkHtml, "ToPdf");

  cWkHtmlToPdfGlobalSettings = rb_define_class_under(mWkHtmlToPdf, "GlobalSettings", rb_cObject);
  rb_define_alloc_func(cWkHtmlToPdfGlobalSettings, wkhtml_topdf_globalsettings_alloc);
  rb_define_method(cWkHtmlToPdfGlobalSettings, "[]=", wkhtml_topdf_globalsettings_aset, 2);
  rb_define_method(cWkHtmlToPdfGlobalSettings, "[]", wkhtml_topdf_globalsettings_aref, 1);

  cWkHtmlToPdfObjectSettings = rb_define_class_under(mWkHtmlToPdf, "ObjectSettings", rb_cObject);
  rb_define_alloc_func(cWkHtmlToPdfObjectSettings, wkhtml_topdf_objectsettings_alloc);
  rb_define_method(cWkHtmlToPdfObjectSettings, "[]=", wkhtml_topdf_objectsettings_aset, 2);
  rb_define_method(cWkHtmlToPdfObjectSettings, "[]", wkhtml_topdf_objectsettings_aref, 1);

  cWkHtmlToPdfConverter = rb_define_class_under(mWkHtmlToPdf, "Converter", rb_cObject);
  /*
  TODO
  rb_define_singleton_method(klass, "new", constructor, 1); //Uses Data_Wrap_Struct -> rb_obj_call_init(t_data, 1, argv);
  rb_define_method(klass, "initialize", initialize, 1);
  */
  rb_define_singleton_method(cWkHtmlToPdfConverter, "create", wkhtml_topdf_converter_create, 1);
  rb_define_method(cWkHtmlToPdfConverter, "add_object", wkhtml_topdf_converter_add_object, 2);
  rb_define_method(cWkHtmlToPdfConverter, "convert", wkhtml_topdf_converter_convert, 0);
  rb_define_method(cWkHtmlToPdfConverter, "http_error_code", wkhtml_topdf_converter_http_error_code, 0);
  rb_define_method(cWkHtmlToPdfConverter, "get_output", wkhtml_topdf_converter_get_output, 0);
  //Force use of factory method
  rb_undef_alloc_func(cWkHtmlToPdfConverter);
  rb_undef_method(rb_singleton_class(cWkHtmlToPdfConverter), "new");

  mWkHtmlToImage = rb_define_module_under(mWkHtml, "ToImage");

  cWkHtmlToImageGlobalSettings = rb_define_class_under(mWkHtmlToImage, "GlobalSettings", rb_cObject);
  rb_define_alloc_func(cWkHtmlToImageGlobalSettings, wkhtml_toimage_globalsettings_alloc);
  rb_define_method(cWkHtmlToImageGlobalSettings, "[]=", wkhtml_toimage_globalsettings_aset, 2);
  rb_define_method(cWkHtmlToImageGlobalSettings, "[]", wkhtml_toimage_globalsettings_aref, 1);

  cWkHtmlToImageConverter = rb_define_class_under(mWkHtmlToImage, "Converter", rb_cObject);
  rb_define_singleton_method(cWkHtmlToImageConverter, "create", wkhtml_toimage_converter_create, 2);
  rb_define_method(cWkHtmlToImageConverter, "convert", wkhtml_toimage_converter_convert, 0);
  rb_define_method(cWkHtmlToImageConverter, "http_error_code", wkhtml_toimage_converter_http_error_code, 0);
  rb_define_method(cWkHtmlToImageConverter, "get_output", wkhtml_toimage_converter_get_output, 0);
  //Force use of factory method
  rb_undef_alloc_func(cWkHtmlToImageConverter);
  rb_undef_method(rb_singleton_class(cWkHtmlToImageConverter), "new");
}

void 
Init_gtk_frame(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_FRAME, "Frame", mGtk);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(set_label_align, 2);
    RG_DEF_METHOD(label_align, 0);
    rb_undef_method(RG_TARGET_NAMESPACE, "shadow");
    rb_undef_method(RG_TARGET_NAMESPACE, "shadow=");
    rb_undef_method(RG_TARGET_NAMESPACE, "set_shadow");
}

void
Init_rpm_transaction(void)
{
	rpm_cTransaction = rb_define_class_under(rpm_mRPM, "Transaction", rb_cData);
#if RPM_VERSION_CODE < RPM_VERSION(4,9,0) || RPM_VERSION_CODE >= RPM_VERSION(5,0,0)
	rb_define_method(rpm_cTransaction, "db", rpm_transaction_get_db, 0);
#else
	rb_define_method(rpm_cTransaction, "init_iterator", rpm_transaction_init_iterator, 2);
#endif
	rb_define_method(rpm_cTransaction, "script_file", rpm_transaction_get_script_file, 0);
	rb_define_method(rpm_cTransaction, "script_file=", rpm_transaction_set_script_file, 1);
	rb_define_method(rpm_cTransaction, "install", rpm_transaction_install, 2);
	rb_define_method(rpm_cTransaction, "upgrade", rpm_transaction_upgrade, 2);
#ifdef RPMTS_AVAILABLE
	rb_define_method(rpm_cTransaction, "available", rpm_transaction_available, 2);
#endif
	rb_define_method(rpm_cTransaction, "delete", rpm_transaction_delete, 1);
	rb_define_method(rpm_cTransaction, "check", rpm_transaction_check, 0);
	rb_define_method(rpm_cTransaction, "order", rpm_transaction_order, 0);
	rb_define_method(rpm_cTransaction, "keys", rpm_transaction_keys, 0);
	rb_define_method(rpm_cTransaction, "commit", rpm_transaction_commit, -1);
	rb_define_method(rpm_cTransaction, "abort", rpm_transaction_abort, 0);
	rb_undef_method(rpm_cTransaction, "dup");
	rb_undef_method(rpm_cTransaction, "clone");

    rpm_sCallbackData = rb_struct_define(NULL, "type", "key", "package",
										 "amount", "total", NULL);

	rb_define_const(rpm_mRPM, "CallbackData", rpm_sCallbackData);

	rpm_sProblem = rb_struct_define(NULL, "type", "key", "package",
									"description", NULL);
	rb_define_const(rpm_mRPM, "Problem", rpm_sProblem);

	id_db = rb_intern("db");
	id_sf = rb_intern("script_file");
	id_keys = rb_intern("keys");
	id_commited = rb_intern("commited");
	id_aborted = rb_intern("aborted");
	id_pl = rb_intern("problist");
	id_type = rb_intern("type");
	id_key = rb_intern("key");
	id_pkg = rb_intern("package");
	id_mes = rb_intern("message");
	id_amount = rb_intern("amount");
	id_total = rb_intern("total");
	//id_pkg_cache = rb_intern("package_cache");
	id_file = rb_intern("file");
	id_fdt = rb_intern("fdt");
}

void 
Init_gdk_pixbuf_loader(VALUE mGdk)
{
    VALUE gdkPixbufLoader;
    /* initialize it */
    gdkPixbufLoader = G_DEF_CLASS(GDK_TYPE_PIXBUF_LOADER, "PixbufLoader", mGdk);    

    /* 
     * File Loading, Image Data in Memory
     */
    rb_define_method(gdkPixbufLoader, "initialize", initialize_loader, -1);

    rb_undef_method(gdkPixbufLoader, "dup");
#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
    rb_define_method(gdkPixbufLoader, "format", loader_get_format, 0);
#endif
    rb_define_method(gdkPixbufLoader, "write", loader_write, 1);
    rb_define_method(gdkPixbufLoader, "last_write", last_write, 1);
#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
    rb_define_method(gdkPixbufLoader, "set_size", loader_set_size, 2);
#endif
    rb_define_method(gdkPixbufLoader, "close", loader_close, 0);
    rb_define_method(gdkPixbufLoader, "pixbuf", get_pixbuf, 0);
    rb_define_method(gdkPixbufLoader, "animation", get_animation, 0);
}

void 
Init_gdk_pixbuf_loader(VALUE mGdk)
{
    VALUE RG_TARGET_NAMESPACE;
    /* initialize it */
    RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF_LOADER, "PixbufLoader", mGdk);    

    /* 
     * File Loading, Image Data in Memory
     */
    RG_DEF_METHOD(initialize, -1);

    rb_undef_method(RG_TARGET_NAMESPACE, "dup");
#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
    RG_DEF_METHOD(format, 0);
#endif
    RG_DEF_METHOD(write, 1);
    RG_DEF_METHOD(last_write, 1);
#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
    RG_DEF_METHOD(set_size, 2);
#endif
    RG_DEF_METHOD(close, 0);
    RG_DEF_METHOD(pixbuf, 0);
    RG_DEF_METHOD(animation, 0);
}

void Init_instruction(void)
{
#ifdef RUBY_VM
  VALUE rb_cRubyVM;
  VALUE rb_cInstruction;

  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
  {
    rb_define_const(
        rb_cObject,
        "RubyVM",
        rb_const_get(rb_cObject, rb_intern("VM")));
  }

  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);

  rb_cInstruction = rb_define_class_under(rb_cRubyVM, "Instruction", rb_cObject);
  rb_define_method(rb_cInstruction, "initialize", instruction_initialize, -1);
  rb_define_method(rb_cInstruction, "operands", instruction_operands, 0);
  rb_undef_method(rb_cInstruction, "new");

  define_instruction_subclasses(rb_cInstruction);

  /* Silence compiler warnings about unused static functions */
  insn_name(0);
  insn_op_type(0, 0);
  insn_op_types(0);
#endif
}

//------------------------------------------------------------------------------
// Function: LockDownClass
//
// Description:
//
//  Lock down key methods in a class.
//  
// Returns:
//
// Notes:
//
void
LockDownClass(
	_In_ VALUE klass)
{
	// Prevent scripter from instantiating directly.
	//
	// 'rb_undef_method' undefs an *instance* method of the given class,
	// so for 'new' which is a 'class method', we have to get the
	// object's class.
	//
	rb_undef_method(CLASS_OF(klass), "new");
	
	rb_undef_method(klass, "dup");
	rb_undef_method(klass, "clone");
	
}

void rb_init_apache_connection()
{
    rb_cApacheConnection = rb_define_class_under(rb_mApache, "Connection", rb_cObject);
    rb_undef_method(CLASS_OF(rb_cApacheConnection), "new");
    rb_define_method(rb_cApacheConnection, "aborted?",
                     connection_aborted, 0);
    rb_define_method(rb_cApacheConnection, "keepalive",
                     connection_keepalive, 0);
    rb_define_method(rb_cApacheConnection, "double_reverse",
                     connection_double_reverse, 0);
    rb_define_method(rb_cApacheConnection, "keepalives",
                     connection_keepalives, 0);
    rb_define_method(rb_cApacheConnection, "remote_ip",
		     connection_remote_ip, 0);
    rb_define_method(rb_cApacheConnection, "remote_host",
		     connection_remote_host, 0);
    rb_define_method(rb_cApacheConnection, "remote_port",
		     connection_remote_port, 0);
    rb_define_method(rb_cApacheConnection, "remote_logname",
		     connection_remote_logname, 0);
    rb_define_method(rb_cApacheConnection, "user", connection_user, 0);
    rb_define_method(rb_cApacheConnection, "user=", connection_set_user, 1);
    rb_define_method(rb_cApacheConnection, "auth_type",
		     connection_auth_type, 0);
    rb_define_method(rb_cApacheConnection, "auth_type=",
		     connection_set_auth_type, 1);
    rb_define_method(rb_cApacheConnection, "local_ip",
		     connection_local_ip, 0);
    rb_define_method(rb_cApacheConnection, "local_host",
		     connection_local_host, 0);
    rb_define_method(rb_cApacheConnection, "local_port",
                     connection_local_port, 0);
    rb_define_method(rb_cApacheConnection, "notes",
                     connection_notes, 0);
}

void
Init_zoom_resultset (VALUE mZoom)
{
    VALUE c;
    
    c = rb_define_class_under (mZoom, "ResultSet", rb_cObject); 
    rb_undef_method (CLASS_OF (c), "new");
    rb_define_method (c, "set_option", rbz_resultset_set_option, 2);
    rb_define_method (c, "get_option", rbz_resultset_get_option, 1);
    
    define_zoom_option (c, "start");
    define_zoom_option (c, "count");
    define_zoom_option (c, "presentChunk");
    define_zoom_option (c, "elementSetName");
    define_zoom_option (c, "preferredRecordSyntax");
    define_zoom_option (c, "schema");
    define_zoom_option (c, "setname");
    
    rb_define_method (c, "size", rbz_resultset_size, 0);
    rb_define_alias (c, "length", "size");
    rb_define_method (c, "records", rbz_resultset_records, 0);
    rb_define_method (c, "each_record", rbz_resultset_each_record, 0);
    rb_define_method (c, "[]", rbz_resultset_index, -1);
    
    cZoomResultSet = c;
}

void
rbffi_DynamicLibrary_Init(VALUE moduleFFI)
{
    LibraryClass = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject);
    rb_global_variable(&LibraryClass);
    SymbolClass = rb_define_class_under(LibraryClass, "Symbol", rbffi_PointerClass);
    rb_global_variable(&SymbolClass);

    rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); // backwards compat library
    rb_define_alloc_func(LibraryClass, library_allocate);
    rb_define_singleton_method(LibraryClass, "open", library_open, 2);
    rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0);
    rb_define_method(LibraryClass, "initialize", library_initialize, 2);
    rb_define_method(LibraryClass, "find_symbol", library_dlsym, 1);
    rb_define_method(LibraryClass, "find_function", library_dlsym, 1);
    rb_define_method(LibraryClass, "find_variable", library_dlsym, 1);
    rb_define_method(LibraryClass, "last_error", library_dlerror, 0);
    rb_define_attr(LibraryClass, "name", 1, 0);

    rb_define_alloc_func(SymbolClass, symbol_allocate);
    rb_undef_method(SymbolClass, "new");
    rb_define_method(SymbolClass, "inspect", symbol_inspect, 0);

#define DEF(x) rb_define_const(LibraryClass, "RTLD_" #x, UINT2NUM(RTLD_##x))
    DEF(LAZY);
    DEF(NOW);
    DEF(GLOBAL);
    DEF(LOCAL);

}

/*
 * BasicSocket class
 */
void
Init_basicsocket(void)
{
    rb_cBasicSocket = rb_define_class("BasicSocket", rb_cIO);
    rb_undef_method(rb_cBasicSocket, "initialize");

    rb_define_singleton_method(rb_cBasicSocket, "do_not_reverse_lookup",
			       bsock_do_not_rev_lookup, 0);
    rb_define_singleton_method(rb_cBasicSocket, "do_not_reverse_lookup=",
			       bsock_do_not_rev_lookup_set, 1);
    rb_define_singleton_method(rb_cBasicSocket, "for_fd", bsock_s_for_fd, 1);

    rb_define_method(rb_cBasicSocket, "close_read", bsock_close_read, 0);
    rb_define_method(rb_cBasicSocket, "close_write", bsock_close_write, 0);
    rb_define_method(rb_cBasicSocket, "shutdown", bsock_shutdown, -1);
    rb_define_method(rb_cBasicSocket, "setsockopt", bsock_setsockopt, -1);
    rb_define_method(rb_cBasicSocket, "getsockopt", bsock_getsockopt, 2);
    rb_define_method(rb_cBasicSocket, "getsockname", bsock_getsockname, 0);
    rb_define_method(rb_cBasicSocket, "getpeername", bsock_getpeername, 0);
    rb_define_method(rb_cBasicSocket, "getpeereid", bsock_getpeereid, 0);
    rb_define_method(rb_cBasicSocket, "local_address", bsock_local_address, 0);
    rb_define_method(rb_cBasicSocket, "remote_address", bsock_remote_address, 0);
    rb_define_method(rb_cBasicSocket, "send", rsock_bsock_send, -1);
    rb_define_method(rb_cBasicSocket, "recv", bsock_recv, -1);
    rb_define_method(rb_cBasicSocket, "recv_nonblock", bsock_recv_nonblock, -1);
    rb_define_method(rb_cBasicSocket, "do_not_reverse_lookup", bsock_do_not_reverse_lookup, 0);
    rb_define_method(rb_cBasicSocket, "do_not_reverse_lookup=", bsock_do_not_reverse_lookup_set, 1);
}