|
|||
| Previous < |
Contents ^
|
Next >
|
|
ObjectSpace::each_object
. We can use it to
do all sorts of neat tricks.
For example, to iterate over all objects of type Numeric, you'd
write the following.
a = 102.7
b = 95.1
ObjectSpace.each_object(Numeric) {|x| p x }
|
95.1 102.7 2.718281828 3.141592654 |
Math module defines constants for e and PI; since we are
examining all living objects in the system, these turn up as
well.
However, there is a catch. Let's try the same example with different
numbers.
a = 102
b = 95
ObjectSpace.each_object(Numeric) {|x| p x }
|
2.718281828 3.141592654 |
Fixnum objects we created showed up. That's because
ObjectSpace doesn't know about objects with immediate values:
Fixnum, true, false, and nil.
r = 1..10 # Create a Range object
|
||
list = r.methods
|
||
list.length
|
» |
60
|
list[0..3]
|
» |
["size", "end", "length", "exclude_end?"]
|
r.respond_to?("frozen?")
|
» |
true
|
r.respond_to?("hasKey")
|
» |
false
|
"me".respond_to?("==")
|
» |
true
|
num = 1
|
||
num.id
|
» |
3
|
num.class
|
» |
Fixnum
|
num.kind_of? Fixnum
|
» |
true
|
num.kind_of? Numeric
|
» |
true
|
num.instance_of? Fixnum
|
» |
true
|
num.instance_of? Numeric
|
» |
false
|
Class#superclass
. For
classes and modules,
Module#ancestors
lists both
superclasses and mixed-in modules.
klass = Fixnum begin print klass klass = klass.superclass print " < " if klass end while klass puts p Fixnum.ancestors |
Fixnum < Integer < Numeric < Object [Fixnum, Integer, Precision, Numeric, Comparable, Object, Kernel] |
ObjectSpace to iterate
over all Class objects:
ObjectSpace.each_object(Class) do |aClass| # ... end |
class Demo
|
||
private
|
||
def privMethod
|
||
end
|
||
protected
|
||
def protMethod
|
||
end
|
||
public
|
||
def pubMethod
|
||
end
|
||
|
||
def Demo.classMethod
|
||
end
|
||
|
||
CONST = 1.23
|
||
end
|
||
|
||
Demo.private_instance_methods
|
» |
["privMethod"]
|
Demo.protected_instance_methods
|
» |
["protMethod"]
|
Demo.public_instance_methods
|
» |
["pubMethod"]
|
Demo.singleton_methods
|
» |
["classMethod"]
|
Demo.constants - Demo.superclass.constants
|
» |
["CONST"]
|
Module.constants
returns
all the constants available via a module, including
constants from the module's superclasses. We're not interested in
those just at the moment, so we'll subtract them from our list.
Given a list of method names, we might now be tempted to try calling them.
Fortunately, that's easy with Ruby.
typedef struct {
char *name;
void (*fptr)();
} Tuple;
Tuple list[]= {
{ "play", fptr_play },
{ "stop", fptr_stop },
{ "record", fptr_record },
{ 0, 0 },
};
...
void dispatch(char *cmd) {
int i = 0;
for (; list[i].name; i++) {
if (strncmp(list[i].name,cmd,strlen(cmd)) == 0) {
list[i].fptr();
return;
}
}
/* not found */
}
|
commands), and ask that object to execute a method called the
same name as the command string.
commands.send(commandString) |
send: it
works on any object.
"John Coltrane".send(:length)
|
» |
13
|
"Miles Davis".send("sub", /iles/, '.')
|
» |
"M. Davis"
|
Method objects. A
Method object is like a Proc object: it represents a chunk of
code and a context in which it executes. In this case, the code is the
body of the method, and the context is the object that created the
method. Once we have our Method object, we can execute it sometime
later by sending it the message call.
trane = "John Coltrane".method(:length)
|
||
miles = "Miles Davis".method("sub")
|
||
|
||
trane.call
|
» |
13
|
miles.call(/iles/, '.')
|
» |
"M. Davis"
|
Method object around as you would any other
object, and when you invoke
Method#call
, the method is run just
as if you had invoked it on the original object. It's like having a
C-style function pointer but in a fully object-oriented style.
You can also use Method objects with iterators.
def double(a)
|
||
2*a
|
||
end
|
||
|
||
mObj = method(:double)
|
||
|
||
[ 1, 3, 5, 7 ].collect(&mObj)
|
» |
[2, 6, 10, 14]
|
eval
method (and its variations such as
class_eval, module_eval, and instance_eval) will
parse and execute an arbitrary string of legal Ruby source code.
trane = %q{"John Coltrane".length}
|
||
miles = %q{"Miles Davis".sub(/iles/, '.')}
|
||
|
||
eval trane
|
» |
13
|
eval miles
|
» |
"M. Davis"
|
eval, it can be helpful to state explicitly the
context in which the expression should be evaluated, rather than using
the current context. You can obtain a context by calling
Kernel#binding
at the desired point.
class CoinSlot def initialize(amt=Cents.new(25)) @amt = amt $here = binding end end a = CoinSlot.new eval "puts @amt", $here eval "puts @amt" |
$0.25USD nil |
eval evaluates @amt in the context of the instance
of class CoinSlot. The second eval evaluates @amt in
the context of Object, where the instance variable @amt is
not defined.
Object#send
,
Method#call
, and the various flavors of eval.
You may prefer to use any one of these techniques depending on your
needs, but be aware that eval is significantly slower than the
others (or, for optimistic readers, send and call are
significantly faster than eval).
require "benchmark" # from the Ruby Application Archive
include Benchmark
test = "Stormy Weather"
m = test.method(:length)
n = 100000
bm(12) {|x|
x.report("call") { n.times { m.call } }
x.report("send") { n.times { test.send(:length) } }
x.report("eval") { n.times { eval "test.length" } }
}
|
user system total real call 0.220000 0.000000 0.220000 ( 0.214065) send 0.210000 0.000000 0.210000 ( 0.217070) eval 2.540000 0.000000 2.540000 ( 2.518311) |
Kernel::system
[This Eiffel-inspired
idiom of renaming a
feature and redefining a new one is very useful, but be aware that
it can cause problems. If a subclass does the same thing, and
renames the methods using the same names, you'll end up with an
infinite loop. You can avoid this by aliasing your methods to a
unique symbol name or by using a consistent naming convention.]
and substitute it with one of your own that both logs the command and
calls the original Kernel method.
module Kernel
alias_method :old_system, :system
def system(*args)
result = old_system(*args)
puts "system(#{args.join(', ')}) returned #{result}"
result
end
end
system("date")
system("kangaroo", "-hop 10", "skippy")
|
Sun Jun 9 00:09:44 CDT 2002 system(date) returned true system(kangaroo, -hop 10, skippy) returned false |
Class#new
, the method that's called to allocate space for a new
object. The technique isn't perfect---some built-in objects, such as
literal strings, are constructed without calling new---but
it'll work just fine for objects we write.
class Class alias_method :old_new, :new def new(*args) result = old_new(*args) result.timestamp = Time.now return result end end |
Object itself.
class Object def timestamp return @timestamp end def timestamp=(aTime) @timestamp = aTime end end |
class Test
|
||
end
|
||
|
||
obj1 = Test.new
|
||
sleep 2
|
||
obj2 = Test.new
|
||
|
||
obj1.timestamp
|
» |
Sun Jun 09 00:09:45 CDT 2002
|
obj2.timestamp
|
» |
Sun Jun 09 00:09:47 CDT 2002
|
| Event | Callback Method | |||||||
| Adding an instance method |
Module#method_added
|
|||||||
| Adding a singleton method |
Kernel::singleton_method_added
|
|||||||
| Subclassing a class |
Class#inherited
|
|||||||
| Mixing in a module |
Module#extend_object
|
|||||||
set_trace_func
executes a Proc with all sorts of juicy
debugging information whenever a new source line is executed,
methods are called, objects are created, and so on. There's a full description
on page 422, but here's a taste.
class Test
def test
a = 1
b = 2
end
end
set_trace_func proc { |event, file, line, id, binding, classname|
printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
}
t = Test.new
t.test
|
line prog.rb:11 false c-call prog.rb:11 new Class c-call prog.rb:11 initialize Object c-return prog.rb:11 initialize Object c-return prog.rb:11 new Class line prog.rb:12 false call prog.rb:2 test Test line prog.rb:3 test Test line prog.rb:4 test Test return prog.rb:4 test Test |
trace_var (described
on page 427) that lets you add a hook to a global variable; whenever
an assignment is made to the global, your Proc object is invoked.
caller,
which returns an Array of
String objects representing the current call stack.
def catA
puts caller.join("\n")
end
def catB
catA
end
def catC
catB
end
catC
|
prog.rb:5:in `catB' prog.rb:8:in `catC' prog.rb:10 |
Marshal::dump
. Typically, you will dump an entire object tree
starting with some given object. Later on, you can reconstitute the
object using
Marshal::load
.
Here's a short example. We have a class Chord that holds a
collection of musical notes. We'd like to save away a particularly
wonderful chord so our grandchildren can load it into Ruby Version
23.5 and savor it, too. Let's start off with the classes for Note
and Chord.
class Note
attr :value
def initialize(val)
@value = val
end
def to_s
@value.to_s
end
end
class Chord
def initialize(arr)
@arr = arr
end
def play
@arr.join('-')
end
end
|
Marshal::dump
to save
a serialized version of it to disk.
c = Chord.new( [ Note.new("G"), Note.new("Bb"),
Note.new("Db"), Note.new("E") ] )
File.open("posterity", "w+") do |f|
Marshal.dump(c, f)
end
|
File.open("posterity") do |f|
|
||
chord = Marshal.load(f)
|
||
end
|
||
|
||
chord.play
|
» |
"G-Bb-Db-E"
|
IO, and singleton objects cannot be saved outside of the
running Ruby environment (a TypeError will be raised if you try).
Even if your object doesn't contain one of these problematic objects,
you may want to take control of object serialization yourself.
Marshal provides the hooks you need. In the objects that require
custom serialization, simply implement two methods: an instance method
called _dump,
which writes the object out to a string, and a
class method called _load, which reads a string that you'd
previously created and converts it into a new object.
For instance, here is a sample class that defines its own
serialization.
For whatever reasons, Special doesn't want to save one of its
internal data members, ``@volatile''.
class Special
def initialize(valuable)
@valuable = valuable
@volatile = "Goodbye"
end
def _dump(depth)
@valuable.to_str
end
def Special._load(str)
result = Special.new(str);
end
def to_s
"#{@valuable} and #{@volatile}"
end
end
a = Special.new("Hello, World")
data = Marshal.dump(a)
obj = Marshal.load(data)
puts obj
|
Hello, World and Goodbye |
Marshal
beginning on page 428.
require 'drb'
class TestServer
def doit
"Hello, Distributed World"
end
end
aServerObject = TestServer.new
DRb.start_service('druby://localhost:9000', aServerObject)
DRb.thread.join # Don't exit just yet!
|
require 'drb' DRb.start_service() obj = DRbObject.new(nil, 'druby://localhost:9000') # Now use obj p obj.doit |
doit, which
returns a string that the client prints out:
"Hello, Distributed World" |
nil argument to DRbObject indicates that we want
to attach to a new distributed object. We could also use an
existing object.
Ho hum, you say. This sounds like Java's RMI, or CORBA, or whatever.
Yes, it is a functional distributed object mechanism---but it is
written in just 200 lines of Ruby code. No C, nothing fancy, just
plain old Ruby code. Of course, there's no naming service or trader
service, or anything like you'd see in CORBA, but it is simple and
reasonably fast. On the 233MHz test system, this sample code runs at
about 50 remote message calls per second.
And, if you like the look of Sun's JavaSpaces, the basis of their JINI
architecture, you'll be interested to know that drb is distributed with
a short module that does the same kind of thing. JavaSpaces is based
on a technology called Linda. To prove that its Japanese author has a
sense of humor, Ruby's version of Linda is known as ``rinda.''
public
to private, and so on. You can even alter basic types, such
as Class and Object.
Once you get used to this flexibility, it is hard to go back to a
static language such as C++, or even to a half-static language such as
Java.
But then, why would you want to?
| Previous < |
Contents ^
|
Next >
|