Class: Class

Inherits:
Module show all
Defined in:
class.c

Instance Method Summary collapse

Methods inherited from Module

#<, #<=, #<=>, #==, #===, #>, #>=, #alias_method, #ancestors, #append_features, #attr, #attr_accessor, #attr_reader, #attr_writer, #autoload, #autoload?, #class_eval, #class_exec, #class_variable_defined?, #class_variable_get, #class_variable_set, #class_variables, #const_defined?, #const_get, #const_missing, #const_set, constants, #constants, #define_method, #extend_object, #extended, #freeze, #include, #include?, #included, #included_modules, #instance_method, #instance_methods, #method_added, #method_defined?, #method_removed, #method_undefined, #module_eval, #module_exec, #module_function, #name, nesting, #private, #private_class_method, #private_instance_methods, #private_method_defined?, #protected, #protected_instance_methods, #protected_method_defined?, #public, #public_class_method, #public_instance_method, #public_instance_methods, #public_method_defined?, #remove_class_variable, #remove_const, #remove_method, #to_s, #undef_method

Constructor Details

#new(*args) ⇒ Object

Returns a new BasicObject. Arguments are ignored.




# File 'object.c'

/*
 *  call-seq:
 *     Class.new(super_class=Object)   ->    a_class
 *
 *  Creates a new anonymous (unnamed) class with the given superclass
 *  (or <code>Object</code> if no parameter is given). You can give a
 *  class a name by assigning the class object to a constant.
 *
 */

static VALUE
rb_class_initialize(int argc, VALUE *argv, VALUE klass)
{
    VALUE super;

    if (RCLASS_SUPER(klass) != 0 || klass == rb_cBasicObject) {
    rb_raise(rb_eTypeError, "already initialized class");
    }
    if (argc == 0) {
    super = rb_cObject;
    }
    else {
    rb_scan_args(argc, argv, "01", &super);
    rb_check_inheritable(super);
    }
    RCLASS_SUPER(klass) = super;
    rb_make_metaclass(klass, RBASIC(super)->klass);
    rb_class_inherited(super, klass);
    rb_mod_initialize(klass);

    return klass;
}

Instance Method Details

#allocate ⇒ Object

Allocates space for a new object of class's class and does not call initialize on the new instance. The returned object must be an instance of class.

klass = Class.new do
  def initialize(*args)
    @initialized = true
  end

  def initialized?
    @initialized || false
  end
end

klass.allocate.initialized? #=> false

Returns:




# File 'object.c'

/*
 *  call-seq:
 *     class.allocate()   ->   obj
 *
 *  Allocates space for a new object of <i>class</i>'s class and does not
 *  call initialize on the new instance. The returned object must be an
 *  instance of <i>class</i>.
 *
 *      klass = Class.new do
 *        def initialize(*args)
 *          @initialized = true
 *        end
 *
 *        def initialized?
 *          @initialized || false
 *        end
 *      end
 *
 *      klass.allocate.initialized? #=> false
 *
 */

VALUE
rb_obj_alloc(VALUE klass)
{
    VALUE obj;

    if (RCLASS_SUPER(klass) == 0 && klass != rb_cBasicObject) {
    rb_raise(rb_eTypeError, "can't instantiate uninitialized class");
    }
    if (FL_TEST(klass, FL_SINGLETON)) {
    rb_raise(rb_eTypeError, "can't create instance of singleton class");
    }
    obj = rb_funcall(klass, ID_ALLOCATOR, 0, 0);
    if (rb_obj_class(obj) != rb_class_real(klass)) {
    rb_raise(rb_eTypeError, "wrong instance allocation");
    }
    return obj;
}

#inherited(subclass) ⇒ Object

Callback invoked whenever a subclass of the current class is created.

Example:

class Foo
   def self.inherited(subclass)
      puts "New subclass: #{subclass}"
   end
end

class Bar < Foo
end

class Baz < Bar
end

produces:

New subclass: Bar
New subclass: Baz




# File 'object.c'

/*
 * Not documented
 */

static VALUE
rb_obj_dummy(void)
{
    return Qnil;
}

#initialize_copy ⇒ Object

:nodoc:




# File 'object.c'

/* :nodoc: */
VALUE
rb_class_init_copy(VALUE clone, VALUE orig)
{
    if (orig == rb_cBasicObject) {
	rb_raise(rb_eTypeError, "can't copy the root class");
    }
    if (RCLASS_SUPER(clone) != 0 || clone == rb_cBasicObject) {
	rb_raise(rb_eTypeError, "already initialized class");
    }
    if (FL_TEST(orig, FL_SINGLETON)) {
	rb_raise(rb_eTypeError, "can't copy singleton class");
    }
    return rb_mod_init_copy(clone, orig);
}

#new(args, ...) ⇒ Object

Calls allocate to create a new object of class's class, then invokes that object's initialize method, passing it args. This is the method that ends up getting called whenever an object is constructed using .new.

Returns:




# File 'object.c'

/*
 *  call-seq:
 *     class.new(args, ...)    ->  obj
 *
 *  Calls <code>allocate</code> to create a new object of
 *  <i>class</i>'s class, then invokes that object's
 *  <code>initialize</code> method, passing it <i>args</i>.
 *  This is the method that ends up getting called whenever
 *  an object is constructed using .new.
 *
 */

VALUE
rb_class_new_instance(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj;

    obj = rb_obj_alloc(klass);
    rb_obj_call_init(obj, argc, argv);

    return obj;
}

#superclass ⇒ nil

Returns the superclass of class, or nil.

File.superclass          #=> IO
IO.superclass            #=> Object
Object.superclass        #=> BasicObject
class Foo; end
class Bar < Foo; end
Bar.superclass           #=> Foo

returns nil when the given class hasn't a parent class:

BasicObject.superclass   #=> nil

Returns:

  • (nil) 



# File 'object.c'

/*
 *  call-seq:
 *     class.superclass -> a_super_class or nil
 *
 *  Returns the superclass of <i>class</i>, or <code>nil</code>.
 *
 *     File.superclass          #=> IO
 *     IO.superclass            #=> Object
 *     Object.superclass        #=> BasicObject
 *     class Foo; end
 *     class Bar < Foo; end
 *     Bar.superclass           #=> Foo
 *
 *  returns nil when the given class hasn't a parent class:
 *
 *     BasicObject.superclass   #=> nil
 *
 */

static VALUE
rb_class_superclass(VALUE klass)
{
    VALUE super = RCLASS_SUPER(klass);

    if (!super) {
    if (klass == rb_cBasicObject) return Qnil;
    rb_raise(rb_eTypeError, "uninitialized class");
    }
    while (TYPE(super) == T_ICLASS) {
    super = RCLASS_SUPER(super);
    }
    if (!super) {
    return Qnil;
    }
    return super;
}