Project

General

Profile

Bug #10526 » doc_object_c.patch

stomar (Marcus Stollsteimer), 11/19/2014 09:28 PM

View differences:

object.c (Arbeitskopie)
* capacity of a Fixnum will be truncated before being used.
*
* The hash value for an object may not be identical across invocations or
* implementations of ruby. If you need a stable identifier across ruby
* implementations of Ruby. If you need a stable identifier across Ruby
* invocations and implementations you will need to generate one with a custom
* method.
*/
......
* obj.singleton_class -> class
*
* Returns the singleton class of <i>obj</i>. This method creates
* a new singleton class if <i>obj</i> does not have it.
* a new singleton class if <i>obj</i> does not have one.
*
* If <i>obj</i> is <code>nil</code>, <code>true</code>, or
* <code>false</code>, it returns NilClass, TrueClass, or FalseClass,
......
* obj.clone -> an_object
*
* Produces a shallow copy of <i>obj</i>---the instance variables of
* <i>obj</i> are copied, but not the objects they reference. Copies
* the frozen and tainted state of <i>obj</i>. See also the discussion
* under <code>Object#dup</code>.
* <i>obj</i> are copied, but not the objects they reference.
* <code>clone</code> copies the frozen and tainted state of <i>obj</i>.
* See also the discussion under <code>Object#dup</code>.
*
* class Klass
* attr_accessor :str
......
* obj.dup -> an_object
*
* Produces a shallow copy of <i>obj</i>---the instance variables of
* <i>obj</i> are copied, but not the objects they reference. <code>dup</code>
* copies the tainted state of <i>obj</i>.
* <i>obj</i> are copied, but not the objects they reference.
* <code>dup</code> copies the tainted state of <i>obj</i>.
*
* This method may have class-specific behavior. If so, that
* behavior will be documented under the #+initialize_copy+ method of
......
* typically uses the class of the descendant object to create the new
* instance.
*
* When using #dup any modules that the object has been extended with will not
* When using #dup, any modules that the object has been extended with will not
* be copied.
*
* class Klass
......
* Returns a string representing <i>obj</i>. The default
* <code>to_s</code> prints the object's class and an encoding of the
* object id. As a special case, the top-level object that is the
* initial execution context of Ruby programs returns ``main.''
* initial execution context of Ruby programs returns ``main''.
*/
VALUE
......
/*
* If the default external encoding is ASCII compatible, the encoding of
* inspected result must be compatible with it.
* the inspected result must be compatible with it.
* If the default external encoding is ASCII incompatible,
* the result must be ASCII only.
*/
......
* obj.inspect -> string
*
* Returns a string containing a human-readable representation of <i>obj</i>.
* By default, show the class name and the list of the instance variables and
* The default <code>inspect</code> shows the object's class name,
* an encoding of the object id, and a list of the instance variables and
* their values (by calling #inspect on each of them).
* User defined classes should override this method to make better
* User defined classes should override this method to provide a better
* representation of <i>obj</i>. When overriding this method, it should
* return a string whose encoding is compatible with the default external
* encoding.
......
* end
* end
* Bar.new.inspect #=> "#<Bar:0x0300c868 @bar=1>"
*
* class Baz
* def to_s
* "baz"
* end
* end
* Baz.new.inspect #=> "#<Baz:0x0300c868>"
*/
static VALUE
......
/*
* call-seq:
* obj.tap{|x|...} -> obj
* obj.tap{|obj| ... } -> obj
*
* Yields <code>x</code> to the block, and then returns <code>x</code>.
* Yields self to the block, and then returns self.
* The primary purpose of this method is to "tap into" a method chain,
* in order to perform operations on intermediate results within the chain.
*
* (1..10) .tap {|x| puts "original: #{x.inspect}"}
* .to_a .tap {|x| puts "array: #{x.inspect}"}
* .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
* .map { |x| x*x } .tap {|x| puts "squares: #{x.inspect}"}
* (1..10) .tap {|x| puts "original: #{x.inspect}" }
* .to_a .tap {|x| puts "array: #{x.inspect}" }
* .select {|x| x%2==0 } .tap {|x| puts "evens: #{x.inspect}" }
* .map {|x| x*x } .tap {|x| puts "squares: #{x.inspect}" }
*
*/
......
* class Baz < Bar
* end
*
* produces:
* <em>produces:</em>
*
* New subclass: Bar
* New subclass: Baz
......
* def some_instance_method() end
* end
*
* produces:
* <em>produces:</em>
*
* Adding :some_instance_method
*
......
* remove_method :some_instance_method
* end
*
* produces:
* <em>produces:</em>
*
* Removing :some_instance_method
*
......
*
* Objects that are marked as tainted will be restricted from various built-in
* methods. This is to prevent insecure data, such as command-line arguments
* or strings read from Kernel#gets, from inadvertently compromising the users
* or strings read from Kernel#gets, from inadvertently compromising the user's
* system.
*
* To check whether an object is tainted, use #tainted?
* To check whether an object is tainted, use #tainted?.
*
* You should only untaint a tainted object if your code has inspected it and
* determined that it is safe. To do so use #untaint
* determined that it is safe. To do so use #untaint.
*
* In $SAFE level 3, all newly created objects are tainted and you can't untaint
* objects.
......
* call-seq:
* true | obj -> true
*
* Or---Returns <code>true</code>. As <i>anObject</i> is an argument to
* Or---Returns <code>true</code>. As <i>obj</i> is an argument to
* a method call, it is always evaluated; there is no short-circuit
* evaluation in this case.
*
......
/*
* call-seq:
* nil.nil? -> true
* <anything_else>.nil? -> false
* obj.nil? -> true or false
*
* Only the object <i>nil</i> responds <code>true</code> to <code>nil?</code>.
*
* Object.new.nil? #=> false
* nil.nil? #=> true
*/
......
* Instance methods appear as methods in a class when the module is
* included, module methods do not. Conversely, module methods may be
* called without creating an encapsulating object, while instance
* methods may not. (See <code>Module#module_function</code>)
* methods may not. (See <code>Module#module_function</code>.)
*
* In the descriptions that follow, the parameter <i>sym</i> refers
* to a symbol, which is either a quoted string or a
......
* call-seq:
* mod.to_s -> string
*
* Return a string representing this module or class. For basic
* Returns a string representing this module or class. For basic
* classes and modules, this is the name. For singletons, we
* show information on the thing we're attached to as well.
*/
......
* call-seq:
* mod === obj -> true or false
*
* Case Equality---Returns <code>true</code> if <i>anObject</i> is an
* Case Equality---Returns <code>true</code> if <i>obj</i> is an
* instance of <i>mod</i> or one of <i>mod</i>'s descendants. Of
* limited use for modules, but can be used in <code>case</code>
* statements to classify objects by class.
......
* is the same as <i>other</i>. Returns
* <code>nil</code> if there's no relationship between the two.
* (Think of the relationship in terms of the class definition:
* "class A<B" implies "A<B").
* "class A<B" implies "A<B".)
*
*/
......
* Returns true if <i>mod</i> is a subclass of <i>other</i>. Returns
* <code>nil</code> if there's no relationship between the two.
* (Think of the relationship in terms of the class definition:
* "class A<B" implies "A<B").
* "class A<B" implies "A<B".)
*
*/
......
* two modules are the same. Returns
* <code>nil</code> if there's no relationship between the two.
* (Think of the relationship in terms of the class definition:
* "class A<B" implies "B>A").
* "class A<B" implies "B>A".)
*
*/
......
* Returns true if <i>mod</i> is an ancestor of <i>other</i>. Returns
* <code>nil</code> if there's no relationship between the two.
* (Think of the relationship in terms of the class definition:
* "class A<B" implies "B>A").
* "class A<B" implies "B>A".)
*
*/
......
* class Bar < Foo; end
* Bar.superclass #=> Foo
*
* returns nil when the given class hasn't a parent class:
* Returns nil when the given class does not have a parent class:
*
* BasicObject.superclass #=> nil
*
......
* mod.const_get(sym, inherit=true) -> obj
* mod.const_get(str, inherit=true) -> obj
*
* Checks for a constant with the given name in <i>mod</i>
* Checks for a constant with the given name in <i>mod</i>.
* If +inherit+ is set, the lookup will also search
* the ancestors (and +Object+ if <i>mod</i> is a +Module+.)
* the ancestors (and +Object+ if <i>mod</i> is a +Module+).
*
* The value of the constant is returned if a definition is found,
* otherwise a +NameError+ is raised.
......
* Object.const_get 'Foo::Baz::VAL' # => 10
* Object.const_get 'Foo::Baz::VAL', false # => NameError
*
* If neither +sym+ nor +str+ is not a valid constant name a NameError will be
* If the argument is not a valid constant name a +NameError+ will be
* raised with a warning "wrong constant name".
*
* Object.const_get 'foobar' #=> NameError: wrong constant name foobar
......
* Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0) #=> 3.14285714285714
* Math::HIGH_SCHOOL_PI - Math::PI #=> 0.00126448926734968
*
* If neither +sym+ nor +str+ is not a valid constant name a NameError will be
* If +sym+ or +str+ is not a valid constant name a +NameError+ will be
* raised with a warning "wrong constant name".
*
* Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar
......
*
* In this case, the same logic for autoloading applies.
*
* If the argument is not a valid constant name +NameError+ is raised with the
* If the argument is not a valid constant name a +NameError+ is raised with the
* message "wrong constant name _name_":
*
* Hash.const_defined? 'foobar' #=> NameError: wrong constant name foobar
......
* obj.instance_variable_set(symbol, obj) -> obj
* obj.instance_variable_set(string, obj) -> obj
*
* Sets the instance variable names by <i>symbol</i> to
* <i>object</i>, thereby frustrating the efforts of the class's
* Sets the instance variable named by <i>symbol</i> to the given
* object, thereby frustrating the efforts of the class's
* author to attempt to provide proper encapsulation. The variable
* did not have to exist prior to this call.
* does not have to exist prior to this call.
* If the instance variable name is passed as a string, that string
* is converted to a symbol.
*
......
*
* Returns the value of the given class variable (or throws a
* <code>NameError</code> exception). The <code>@@</code> part of the
* variable name should be included for regular class variables
* variable name should be included for regular class variables.
* String arguments are converted to symbols.
*
* class Fred
......
* obj.class_variable_set(symbol, obj) -> obj
* obj.class_variable_set(string, obj) -> obj
*
* Sets the class variable names by <i>symbol</i> to
* <i>object</i>.
* Sets the class variable named by <i>symbol</i> to the given
* object.
* If the class variable name is passed as a string, that string
* is converted to a symbol.
*
......
/*
* call-seq:
* Integer(arg,base=0) -> integer
* Integer(arg, base=0) -> integer
*
* Converts <i>arg</i> to a <code>Fixnum</code> or <code>Bignum</code>.
* Numeric types are converted directly (with floating point numbers
* being truncated). <i>base</i> (0, or between 2 and 36) is a base for
* being truncated). <i>base</i> (0, or between 2 and 36) is a base for
* integer string representation. If <i>arg</i> is a <code>String</code>,
* when <i>base</i> is omitted or equals to zero, radix indicators
* when <i>base</i> is omitted or equals zero, radix indicators
* (<code>0</code>, <code>0b</code>, and <code>0x</code>) are honored.
* In any case, strings should be strictly conformed to numeric
* representation. This behavior is different from that of
* <code>String#to_i</code>. Non string values will be converted using
* <code>to_int</code>, and <code>to_i</code>. Passing <code>nil</code>
* <code>String#to_i</code>. Non string values will be converted by first
* trying <code>to_int</code>, then <code>to_i</code>. Passing <code>nil</code>
* raises a TypeError.
*
* Integer(123.999) #=> 123
......
* Float(arg) -> float
*
* Returns <i>arg</i> converted to a float. Numeric types are converted
* directly, the rest are converted using <i>arg</i>.to_f. As of Ruby
* 1.8, converting <code>nil</code> generates a <code>TypeError</code>.
* directly, the rest are converted using <i>arg</i>.to_f.
* Converting <code>nil</code> generates a <code>TypeError</code>.
*
* Float(1) #=> 1.0
* Float("123.456") #=> 123.456
......
* call-seq:
* String(arg) -> string
*
* Returns <i>arg</i> as an <code>String</code>.
* Returns <i>arg</i> as a <code>String</code>.
*
* First tries to call its <code>to_str</code> method, then its <code>to_s</code> method.
*
......
*
* Returns +arg+ as an Array.
*
* First tries to call Array#to_ary on +arg+, then Array#to_a.
* First tries to call <code>to_ary</code> on +arg+, then <code>to_a</code>.
*
* Array(1..5) #=> [1, 2, 3, 4, 5]
*/
......
* Typically, you create a new class by using:
*
* class Name
* # some class describing the class behavior
* # some code describing the class behavior
* end
*
* When a new class is created, an object of type Class is initialized and
......
* <code>Class</code>:
*
* class Class
* alias oldNew new
* def new(*args)
* print "Creating a new ", self.name, "\n"
* oldNew(*args)
* end
* end
* alias old_new new
* def new(*args)
* print "Creating a new ", self.name, "\n"
* old_new(*args)
* end
* end
*
* class Name
* end
*
* class Name
* end
* n = Name.new
*
*
* n = Name.new
*
* <em>produces:</em>
*
* Creating a new Name
*
* Classes, modules, and objects are interrelated. In the diagram
* that follows, the vertical arrows represent inheritance, and the
* parentheses meta-classes. All metaclasses are instances
* parentheses metaclasses. All metaclasses are instances
* of the class `Class'.
* +---------+ +-...
* | | |
......
*
* BasicObject does not include Kernel (for methods like +puts+) and
* BasicObject is outside of the namespace of the standard library so common
* classes will not be found without a using a full class path.
* classes will not be found without using a full class path.
*
* A variety of strategies can be used to provide useful portions of the
* standard library to subclasses of BasicObject. A subclass could
......
*
* Object is the default root of all Ruby objects. Object inherits from
* BasicObject which allows creating alternate object hierarchies. Methods
* on object are available to all classes unless explicitly overridden.
* on Object are available to all classes unless explicitly overridden.
*
* Object mixes in the Kernel module, making the built-in kernel functions
* globally accessible. Although the instance methods of Object are defined
(1-1/2)