Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:20:07Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. The term Delegation was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth.

Hence delegation means simply passing off a task to someone else so as to complete it on its behalf.

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate. Thus delegation is like inheritance done manually through object composition.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:19:26Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. The term Delegation was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

Hence delegation means passing off a task to someone else so as to complete it on its behalf.

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate. Thus delegation is like inheritance done manually through object composition.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:19:16Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. The term Delegation was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

Hence delegation means passing off a task to someone else so as to complete it on its behalf.

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate. Thus delegation is like inheritance done manually through object composition.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:19:09Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. The term Delegation was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

Hence delegation means passing off a task to someone else so as to complete it on its behalf.

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate. Thus delegation is like inheritance done manually through object composition.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:18:55Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. The term Delegation was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

Hence delegation means passing off a task to someone else so as to complete it on its behalf.

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate. Thus delegation is like inheritance done manually through object composition.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:12:21Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. The term Delegation was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:11:41Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means "passing a duty off to someone or something else".

In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:09:12Z

Csgodbol: /* Delegation */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means passing a duty off to someone or something else.

In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.
Thus it refers to one object relying upon another to provide a specified set of functionalities.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:08:01Z

Csgodbol: /* Delegation */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means passing a duty off to someone or something else.

In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. It provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-25T00:01:29Z

Csgodbol: /* Delegation */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means passing a duty off to someone or something else.

In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].

Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-24T23:56:32Z

Csgodbol:

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means passing a duty off to someone or something else.

In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-24T23:52:59Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means passing a duty off to someone or something else.

In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.

Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.
Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-24T23:52:38Z

Csgodbol: /* Introduction */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities. In simple words, it means passing a duty off to someone or something else.
In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls.
Delegation is a simple yet, powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation wherein one object defers a task to another object, known as the delegate.
Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibility for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [19]]

= Situations where you can use delegation =

Consider following situation[http://www.khelll.com/blog/ruby/delegation-in-ruby/ [20]]:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7] ]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object[http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html[10]]
| use delegation [http://dev.perl.org/perl6/rfc/193.html [14]]

attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.[http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ [13]]
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method [http://wiki.tcl.tk/11033 [12]]
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.[[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html [11]]
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as shown in the table above. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[9] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[19] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[20] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[21] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[http://api.jquery.com/delegate/ Delegation in Jquery]
*[http://www.programmingvideotutorials.com/csharp/csharp-delegates C# delegates]
*[http://media.pragprog.com/titles/dscpq/delegates.pdf Cocoa programming]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:49:08Z

Csgodbol:

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7]]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html]
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]

[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:46:30Z

Csgodbol: /* References and Notes */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7]]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html]
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:32:19Z

Csgodbol: /* Delegation as a Language Feature */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based programming]. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7]]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time # will give output as Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new #Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html]
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:27:56Z

Csgodbol: /* Table of Comparison */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7]]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html]
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:27:29Z

Csgodbol:

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:-

Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning [7]]:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''[ http://en.wikipedia.org/wiki/C%2B%2B C++]'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''[http://en.wikipedia.org/wiki/Perl_6 Perl 6]'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html]
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''[http://en.wikipedia.org/wiki/Python_(programming_language) Python]'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''[http://en.wikipedia.org/wiki/Php PHP]'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''[http://en.wikipedia.org/wiki/Tcl Tcl]'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''[http://en.wikipedia.org/wiki/Java_(programming_language) Java]'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''[http://en.wikipedia.org/wiki/Objective_c Objective-C]'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''[http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://www.mail-archive.com/perl6-language-objects@perl.org/msg00512.html Delegation in Perl]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[18] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:10:59Z

Csgodbol: /* Delegation vs Inheritance */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance] is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 2 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

SingleForwardable module:Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

2)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''PHP'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''Tcl'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''Java'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''Objective-C'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''Ruby'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''C#'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:10:42Z

Csgodbol: /* Delegation vs Inheritance */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance :
* [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance]is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
* Forwardable
* SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''PHP'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''Tcl'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''Java'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''Objective-C'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''Ruby'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''C#'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T20:09:45Z

Csgodbol: /* Delegation vs Inheritance */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

[http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) Inheritance]:
* Inheritance is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning]:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation. It has two modules
a)Forwardable
b)SingleForwardable:

Forwardable module:-

Using the methods def_delegator and def_delegators the Forwardable module provides delegation of specified methods to a designated object.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' Using the methods def_delegators, the [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object. This module is similar to Forwardable, but instead of their defining classes, it works on objects themselves.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby.

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''PHP'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''Tcl'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''Java'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''Objective-C'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''Ruby'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''C#'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]
*[17] [http://www.scribd.com/doc/27239260/Rails-Magazine-Issue-1-The-Beginning Rails Magazine]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T19:54:25Z

Csgodbol: /* Example of delegation in Ruby */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance:
* Inheritance is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation, it has 2 modules Forwardable and SingleForwardable:

Forwardable module

The Forwardable module provides delegation of specified methods to a designated object, using the methods def_delegator and def_delegators.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' The [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object, using the methods def_delegators. This module is similar to Forwardable, but it works on objects themselves, instead of their defining classes.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
#using forwardable module
require "date"
#using data module
Date = Date.today # output will be <Date: 4909665/2,0,2299161>
# Preparing object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161>
# Adding delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
#using delegate module
require "date"
#using date module
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! '''Syntax for implementing Delegation'''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)
def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''PHP'''
| Yes
| Class Delegator
{
function __construct() {$this->delegate = NULL ; }
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}
class Delegate {function thing() {return 'Delegate Implementation' ;}}
$a = new Delegator() ;
print "{$a->operation()}\n" ;
$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;
$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''Tcl'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''Java'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''Objective-C'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''Ruby'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''C#'''
| Yes.Delegate keyword is used to create a delegate and the type of a delegate is defined by the name of the delegate.
| //declaring a delegate named 'Del' that can encapsulate a method that takes a string as an argument and returns void
public delegate void Del(string message);
// Creating a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiating the delegate.
Del handler = DelegateMethod;
// Calling the delegate.
handler("Hello World");

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T19:26:56Z

Csgodbol: /* References and Notes */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance:
* Inheritance is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation, it has 2 modules Forwardable and SingleForwardable:

Forwardable module

The Forwardable module provides delegation of specified methods to a designated object, using the methods def_delegator and def_delegators.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' The [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object, using the methods def_delegators. This module is similar to Forwardable, but it works on objects themselves, instead of their defining classes.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
require "date"
Date = Date.today # output will be <Date: 4909665/2,0,2299161> # Prepare object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161> # Add delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
require "date"
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! '''Support for Delegation'''
! ''' Syntax for implementing Delegation '''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc.
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)

def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''PHP'''
| Yes
| lass Delegator {
function __construct() {
$this->delegate = NULL ;
}
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}

class Delegate {
function thing() {
return 'Delegate Implementation' ;
}
}

$a = new Delegator() ;
print "{$a->operation()}\n" ;

$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;

$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''Tcl'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''Java'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''Objective-C'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''Ruby'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|-
! '''C#'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] [http://msdn.microsoft.com/en-us/library/ms173172.aspx C# delegation]

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T19:20:48Z

Csgodbol: /* Simple Java Example */

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance:
* Inheritance is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation, it has 2 modules Forwardable and SingleForwardable:

Forwardable module

The Forwardable module provides delegation of specified methods to a designated object, using the methods def_delegator and def_delegators.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' The [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object, using the methods def_delegators. This module is similar to Forwardable, but it works on objects themselves, instead of their defining classes.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
require "date"
Date = Date.today # output will be <Date: 4909665/2,0,2299161> # Prepare object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161> # Add delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
require "date"
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
//class A does the task of class C
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// class C delegates the method to class A
A a = new A();
//delegated methods
void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! ''' Support for Delegation '''
! ''' Syntax for implementing Delegation '''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc.
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| Yes. Using Automatic Delegation (via __getattr__ and __setattr__) it can provide delegation with uses similar to inheritance without any limits and better control.
| def __getattr__(self, attr): return getattr(self.file, attr)

def __setattr__(self, attr, value): return setattr(self.file, attr, value)

|-
! '''PHP'''
| Yes
| lass Delegator {
function __construct() {
$this->delegate = NULL ;
}
function operation() {
if(method_exists($this->delegate, "thing"))
return $this->delegate->thing() ;
return 'default implementation' ;
}
}

class Delegate {
function thing() {
return 'Delegate Implementation' ;
}
}

$a = new Delegator() ;
print "{$a->operation()}\n" ;

$a->delegate = 'A delegate may be any object' ;
print "{$a->operation()}\n" ;

$a->delegate = new Delegate() ;
print "{$a->operation()}\n" ;

|-
! '''Tcl'''
| Yes.Delegation-based model for Tk widgets.Included in Tcllib
| //defining a delegate method
Object instproc delegate {method obj} {
my set delegate($method) $obj
}
Object instproc unknown {m args} {
if {[my exists delegate($m)]} {
eval [my set delegate($m)] $m $args
} elseif {[my exists delegate(*)]} {
eval [my set delegate(*)] $m $args
}
}

|-
! '''Java'''
| Yes. Two ways.
| 1st way: Using an interface called Thingable to specify the type of delegates that respond to thing()
2nd way: Use of traditional wrapper methods.
|-
! '''Objective-C'''
| Yes
| Delegating class has an outlet or property, usually one that is named delegate; if it is an outlet, it includes methods for setting and accessing the value of the outlet

|-
! '''Ruby'''
| Yes
| Wrapper method, delegate lib, forwardable module.

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] []

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T19:18:54Z

Csgodbol:

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance:
* Inheritance is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation, it has 2 modules Forwardable and SingleForwardable:

Forwardable module

The Forwardable module provides delegation of specified methods to a designated object, using the methods def_delegator and def_delegators.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' The [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object, using the methods def_delegators. This module is similar to Forwardable, but it works on objects themselves, instead of their defining classes.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
require "date"
Date = Date.today # output will be <Date: 4909665/2,0,2299161> # Prepare object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161> # Add delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
require "date"
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// delegation
A a = new A();

void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Programming language'''
! ''' Support for Delegation '''
! ''' Syntax for implementing Delegation '''
|-
! '''C++'''
| No in built support.Delegation has to be done manually.Time consuming
| Create a delegation link in delegator.
class MyClass
{
FuBar fb; //delegation link
void Fu() { fb.Fu(); } //
void Bar() { bar.Bar(); }
}

|-
! '''Perl 6'''
| Yes via a pragma for delegating method calls to attributes of an object
|
use delegation
attr1 => [qw( method1 method2 method3 )],
attr2 => [qw( method4 method5 )],
attr3 => __ALL__,
attr4 => __ALL__,
# etc.
;
calls like:

$obj->method3(@args);
$obj->method5(@other_args);
would act as if they were:

$obj->{attr1}->method3(@args);
$obj->{attr2}->method5(@other_args);

|-
! '''Python'''
| yes
| yes

|-
! '''QtRuby'''
| yes
| yes

|-
! '''PHP'''
| yes
| yes

|-
! '''Tcl'''
| yes
| yes

|-
! '''Java'''
| yes
| yes

|-
! '''Objective-C'''
| No
| No

|-
! '''Ruby'''
| yes
| yes

|}

 

= Conclusion =

Thus delegation is a powerful design/reuse technique, and can be viewed as a relationship between objects where one object forwards certain method calls to another object, called its delegate. Delegation is simply passing a duty off to someone/something else.

Delegation pattern is better than inheritance in some ways and it is supported by many languages in various ways as in the given table. Delegation is useful to express relationship among classes, reducing coupling between classes, run-time flexibility – the delegate can be changed at run-time.
It has certain disadvantages too, such as, it is not directly supported by most popular object-oriented languages, also it doesn’t facilitate dynamic polymorphism.

Hence the choice of using delegation depends on various factors such as programming language-support for multiple inheritance or design constraints requiring polymorphism.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] []

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T19:02:41Z

Csgodbol:

'''Delegation-based programming languages'''

''" I do not care how it is done, or who is it assigned to. If something is understood to be placed in the hands of another party, it is delegation " - 'Anonymous'

__TOC__

= Introduction =

Dictionary defines delegation as the assignment of authority and responsibility to another person to carry out specific activities.In programming context it is nothing different. It is basically entrusting an action to another agent. This term was initially introduced by Henry Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems". [http://portal.acm.org/citation.cfm?id=28718] He defines delegation in object oriented languages as a programming language feature making use of the method lookup rules for dispatching so-called self-calls. Thus delegation is like inheritance done manually through object composition.

[[Image:Delegation_self.jpg]]

The above diagram depicts that a message receiver is asking another object (message holder) to do something on its behalf which may delegate it to someone and so on and so forth

== Delegation ==

[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation], is also referred to as [http://en.wikipedia.org/wiki/Object_composition#Aggregation aggregation],consultation, or forwarding. In delegation one class may contain an instance of another class, and delegate some responsibility to that class. This is also referred to as the [http://en.wikipedia.org/wiki/Has-a has-a] relationship. Aggregation should not be confused with [http://en.wikipedia.org/wiki/Object_composition composition]. Both aggregation and composition are used to describe one object containing another object, but composition implies ownership [http://en.wikipedia.org/wiki/Object_composition#Aggregation]. Aggregation is more general and doesn't imply any responsibilities for memory management. A class which contains other classes is called a composite class, while a class being contained is called a composited or composed class [http://en.wikipedia.org/wiki/Object_composition].Delegation is a very powerful reuse technique. The provides run time flexibility. It is also called dynamic inheritance.[http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html]

Delegation can be implemented in many programming languages like Ada, Aikido, C, C#, C++, Common Lisp, D, E, Go, J, Java, JavaScript, Logtalk, Objective-C,Oz, Perl,Perl 6, PHP, PicoLisp, Pop11, Python, Ruby, TCL, Vorpal [http://rosettacode.org/wiki/Delegate]

Example in a Java like language:

class Delegate
{
void doSomething()
{
// "this" is also known as "current", "me" and "self" in other languages
this.callMe()
}
void callMe()
{
print("I am Delegate")
}
}

class Delegator
{
private Delegate d; // delegationlink
public Delegator(Delegate d)
{
this.d = d;
}
void doSomething() {
d.doSomething() // call doSomething() on the Delegate instance
}
void callMe() {
print("I am Delegator")
}
}
d = new Delegate()
b = new Delegator(d) // establish delegation between two objects

Here calling b.doSomething() will result in ''"I am Delegate"'' being printed, since class Delegator "delegates" the method callMe() to a given object of class Delegate.

== Delegation vs Inheritance ==

Inheritance:
* Inheritance is restricted to compile time
* Since it targets type rather than instances, it cannot be removed/changed at runtime
* Inheritance can be statically type-checked

Delegation:
* Delegation takes place at run-time
* Since it takes place at run-time, it can even be removed at run-time
* Cannot guarantee static type-safety (By using interfaces, delegation can be made more flexible and typesafe)

Hints to use Inheritance
* Inheritance is used to create sub-categories of objects
* Mostly identified in 'is-a' relationships between objects
* Inheritance is used when two objects are of the same type but one of the objects may need to have its own customized functionality. The child object just inherits from the parent and writes its own implementation of the feature it needs extra.
* Inheritance can be implemented on objects of the same type only.

[[ Image:Inheritance_db_newtable.gif ]]

Here we have an abstract base class. We extend this to to provide something that we can represent any product by. We then provide a few specialisations for typical products like book,cd.This is a usual case when inheritance is used.

Hints to use Delegation
* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally instead of writing its own implementation
* Identified as 'as-a' relationships where the type of included object may change during runtime.
* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known at compile time.
* Code execution within objects needs to be determined dynamically.

[[ Image:Delegation.jpg ]]

In the above diagram, class C inherits from A. Also, class C has a method called as Call which simple calls the method Call from class B. Hence, class C is delegating its functionality to be implemented by Class B. For this, class C has an object reference to class B.

= Situations where you can use delegation =

Consider following situation:

* Objective: We want a robot to have a heat sensor capability.
* Initial design: So we initially decide to build a Robot class like the one shown below:

[[ Image:robotclass.jpg]]

* Problem with the design: Now all Robots should have a heat sensor. What if some robot did not have a heat sensor capability?
* Solution: So we make a Robot base class and a VolcanoRobot class which inherits from Robot and performs the heat-sensor operations

[[ Image:volcanoclass.jpg]]

* Problem: But with this design whenever we want to modify anything related to the heat sensor, we will have to change the robot class. Also, with our design we have exposed heat sensor methods to Robot class.
* Solution: Hence, in such situations delegation is best.

[[ Image:Ruby_delegation.jpg]]

* New design: Delegate the heat sensor functionality to Heat Sensor class. VolcanoRobot still has the 3 methods that are related to the sensor, but those are wrapper methods, they do nothing but to call the sensor corresponding ones, and that’s exactly what delegation is, just delegate functionality to the contained parts(delegates).

Delegation and composition go hand in hand to provide a flexible neat solution and also it serves the principle “separate changeable code from static one” . The price that one needs to pay for this is that we need wrapper methods, and extra time needed in processing because of the call of these wrapper methods.

== Delegation Design Pattern ==

It is a design pattern in object oriented languages where an object expresses certain behavior to the outside but in reality delegates responsibility for implementing that behaviour to an associated object.

Consider the following examples in java:

class Subordinate // the "delegate"
{
void performTask()
{
System.out.print("Subordinate is performing");
}
}
class Manager // the "delegator"
{
Subordinate slave = new Subordinate(); // create the delegate
void performTask()
{
slave.performTask(); // delegation
}
}
public class Main {
// to the outside world it looks like Manager is actually doing work.
public static void main(String[] args) {
Manager boss = new Manager();
boss.performTask();
}
}

have to write more stuff here. Examples from various programming lang.

== Delegation as a Language Feature ==

Prototype-based programming is a classless type of Object oriented programming technique which performs the work of inheritance in class-based languages. Delegation is the language feature that supports prototype-based programming. It is the mechanism by which code is selected for execution in a dynamic way. Delegation is the process by which a function or method, referred to in the context of one object, is found in another object. When a method is referred to by code defined for an object but is not itself found to be defined in the object the language runtime searches other objects, called delegates. Depending on the object model of the individual language the delegates may defined when the object is created or may be specified by the method-call syntax. The analogous process in a class-based language is dispatching to an inherited method, and an object's delegates perform the role of superclasses in a class-based language.[http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation]

= Delegation in Ruby =

Delegation pattern in Ruby is implemented in 3 ways:

1)'''Forwardable lib:'''[http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/index.html Forwardable lib] is a library that supports delegation, it has 2 modules Forwardable and SingleForwardable:

Forwardable module

The Forwardable module provides delegation of specified methods to a designated object, using the methods def_delegator and def_delegators.

* def_delegator(obj, method, alias = method) : Defines a method method which delegates to obj. If alias is provided, it is used as the name for the delegate method.

* def_delegators(obj, *methods): Shortcut for defining multiple delegator methods, but with no provision for using a different name.

2)'''SingleForwardable module:''' The [http://www.ruby-doc.org/stdlib/libdoc/forwardable/rdoc/classes/SingleForwardable.html SingleForwardable] module provides delegation of specified methods to a designated object, using the methods def_delegators. This module is similar to Forwardable, but it works on objects themselves, instead of their defining classes.

3)'''Delegate lib:'''[http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html Delegate Lib] is another lib that provides delegation in Ruby

== Example of delegation in Ruby ==
Using Forwardable module provided in Ruby, this is how we would implement Robot example seen above:

<pre>
require 'forwardable'
class Robot
# Extending provides class methods
extend Forwardable
# Use of def_delegators
def_delegators :@arm,:package,:stack
# Use of def_delegator
def_delegator :@heat_sensor, :measure ,:measure_heat
def initialize
@heat_sensor = HeatSensor.new
@arm = RobotArm.new
end
end
class HeatSensor
#Celsius or Fahrenheit scale
def measure(scale="c")
t = rand(100)
t = scale=="c" ? t : t * (9/5)
puts "Heat is #{t}° #{scale.upcase}"
end
end
class RobotArm
def stack(boxes_number=1)
puts "Stacking #{boxes_number} box(es)"
end
def package
puts "Packaging"
end
end
</pre>
<pre>
Using Single Forwardable module:

require "forwardable"
require "date"
Date = Date.today # output will be <Date: 4909665/2,0,2299161> # Prepare object for delegation
date.extend SingleForwardable #=> #<Date: 4909665/2,0,2299161> # Add delegation for Time.now
date.def_delegator :Time, "now","with_time"
puts date.with_time #=>Thu Jan 01 23:03:04 +0200 2009

</pre>
<pre>
Using delegate lib:

require "delegate"
require "date"
# Notice the class definition
class CurrentDate < DelegateClass(Date)
def initialize
@date = Date.today
# Pass the object to be delegated to the superclass.
super(@date)
end

def to_s
@date.strftime "%Y/%m/%d"
end

def with_time
Time.now
end
end

cdate = CurrentDate.new ## Notice how delegation works. Instead of doing cdate.date.day and defining attr_accessor for the date just do c.day
puts cdate.day #=>1
puts cdate.month #=>1
puts cdate.year #=>2009 # Testing added methods like to_s
puts cdate #=> 2009/01/01
puts cdate.with_time #=> Thu Jan 01 23:22:20 +0200 2009

</pre>

= Delegation in Java =
Java supports delegation in the same way as other languages do. By using an instance of the class we would have otherwise inherited, and then forwarding messages to the instance we can do delegation in Java.[http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html] e.g. We can associate a class with a thread in two ways:

*By inheriting directly from class Thread.
*By implementing the Runnable interface and delegating to a Thread object.

=== Examples of Delegation in Java ===
Given below are the two examples of delegation, first being a simple one while the second being a complex example.

==== Simple Java Example ====

In this example, the class C has method which does not perform itself and rather delegates to class A, the methods f() and g(). It seems that Class C is doing the work but in reality class A is doing it.[http://en.wikipedia.org/wiki/Delegation_pattern]

<pre>
class A {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class C {
// delegation
A a = new A();

void f() { a.f(); }
void g() { a.g(); }

// normal attributes
X x = new X();
void y() { /* do stuff */ }
}

void main() {
C c = new C();

c.f();
c.g();
}
</pre>

==== Complex Java Example ====

By using interfaces, delegation can be made more flexible[ class-C need not refer to class-A or class-B, delegation is abstracted] and typesafe. Here, class C can delegate to either class A or class B. The implements clauses, improves type safety, since this ensures that each of the class must implements the methods in the interface. The main tradeoff being more code.

<pre>
interface I {
void f();
void g();
}

class A implements I {
void f() { system.out.println("A: doing f()"); }
void g() { system.out.println("A: doing g()"); }
}

class B implements I {
void f() { system.out.println("B: doing f()"); }
void g() { system.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

void f() { i.f(); }
void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

void main() {
C c = new C();

c.f();
c.g();
}

</pre>

= Table of Comparison =
==Cross platform comparison==
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''GUI Toolkit'''
! '''Microsoft Windows|Windows'''
! '''Linux'''
! '''Mac OS X'''
|-
! '''Tk'''
| yes
| yes
| yes
|-
! '''FxRuby'''
| yes
| yes
| yes
|-
! '''WxRuby'''
| yes
| yes
| yes
|-
! '''QtRuby'''
| yes
| yes
| yes
|-
! '''Shoes'''
| yes
| yes
| yes
|-
! '''Swing'''
| yes
| yes
| yes
|-
! '''Monkeybars'''
| yes
| yes
| yes
|-
! '''Cocoa'''
| No
| No
| yes
|-
! '''GTK'''
| yes
| yes
| yes
|}

 

= Conclusion =
Delegation is simply passing a duty off to someone/something else.

= References and Notes =

*[1] [http://portal.acm.org/citation.cfm?id=28718 Using prototypical objects to implement shared behavior in object-oriented systems]
*[2] [http://en.wikipedia.org/wiki/Object_composition#Aggregation Aggregation]
*[3] [http://en.wikipedia.org/wiki/Object_composition Object Composition]
*[4] [http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html Issues Involved in Supporting Behavioral Evolution ]
*[5] [http://rosettacode.org/wiki/Delegate Delegates]
*[6] [http://javalab.cs.uni-bonn.de/research/darwin/delegation.html Darwin Project]
*[7] [http://en.wikipedia.org/wiki/Prototype-based_programming#Delegation Delegation as a Language Feature]
*[8] [http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]
*[9] [http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/delegation.html Delegation Design Pattern]
*[10] [http://en.wikipedia.org/wiki/Delegation_pattern Delegation in Java]
*[11] [http://www.techartifact.com/blogs/2009/05/delegation-versus-inheritance-in-java.html Examples of delegation in Java]
*[12] [http://wiki.tcl.tk/11033 Tcl example]
*[13] [http://code.activestate.com/recipes/52295-automatic-delegation-as-an-alternative-to-inherita/ Python delegation example]
*[14] [http://dev.perl.org/perl6/rfc/193.html Perl delegation]
*[15] [http://rosettacode.org/wiki/Delegate PHP delegation]
*[16] []

= Further Reading =

*[http://en.wikipedia.org/wiki/Delegation_pattern Delegation Pattern in detail]
*[http://www.khelll.com/blog/ruby/delegation-in-ruby/ Delegation in Ruby]

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T14:08:47Z

Csgodbol: /* Complex Java Example */

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T06:10:42Z

Csgodbol: /* Feature Matrix */

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T05:17:37Z

Csgodbol:

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T04:58:20Z

Csgodbol:

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T03:50:22Z

Csgodbol:

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T03:43:27Z

Csgodbol:

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T03:43:12Z

Csgodbol:

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T03:15:05Z

Csgodbol: /* Delegation in Java */

CSC/ECE 517 Fall 2010/ch6 6a PC

2010-11-18T03:13:55Z

Csgodbol:

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:11:29Z

Csgodbol: /* References */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

Merb has set of following features:[14] 

==== Plugins ====

Plugins in Merb are implemented as simple gems. Plugins can either be installed to the system’s repository or bundled into the gems directory in an application’s distribution; Merb applications simply add the /gems folder as an alternate repository.

Plugins for Merb include support for ActiveRecord, DataMapper, and Sequel, with support for SQL sessions, model generation, and database.yml baked in to all three.

==== Controllers ====

Merb’s controllers are made up of two components. First, an AbstractController, which handles layout- and template-finding, instance variable assignment, and before/after filters. Second, a Merb::Controller, which handles request/response semantics.
Controllers also support excellent content-type negotiation.

==== Mailers ====

Merb’s Mailers are implemented on top of AbstractController, so you get all the default controller behavior (including templates, assigns, and before/after filters) for free in the Mailer. But instead of calling render, you call render_mail, which takes options like: render_mail :html => :foo, :text => :bar.
Mailers have their own root directory, which contains controller classes inside it, as well as a views directory, and an optional helpers directory.

==== Parts ====

Parts have a directory structure that’s identical to the Mailer structure, and you can use them to separate out logic about partials that are used throughout the application. Parts take advantage of the flexibility of the AbstractController to allow simple Controller/View delegation.

==== Exceptions ====

Merb handles exceptions also. Instead of exception raising throwing an error in your application, Merb catches certain types of exceptions and allows you to handle them in a controller/view fashion. For instance, raising NotFound will call the Exception#not_found action, which you can customizeas appropriate. Raising an error in this way will also send the appropriate error-code back to the browser.

==== Tests and Specs ====

Merb is testing-framework-agnostic i.e it can be used as Test::Unit, Rspec, or test/spec. All three testing frameworks have built-in support for mock objects that allows to micro-target tests exactly as desired. Merb is modular, hence it’s easy to test the controller without a request object.

==== Generators ====

Merb has a series of generators that allow you get up and running quickly. The Merb application generator is started via merb-gen app application-name. It’ll build a skeleton app that includes folders for controllers, parts, and Mailers.
Merb has controller generators, which create an empty controller file, a view directory with an empty index.html.erb, an empty helper file, and a test file in the chosen spec framework. Merb also has model generators, which are implemented by the ORM plugins, and support a special syntax: merb-gen Product name:string price_in_cents:integer which will generate a new model that implements those attributes using its own syntax. For instance, ActiveRecord would generate a migration, while DataMapper would generate new model using its property syntax.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm
*[14]http://www.merbivore.com

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:11:13Z

Csgodbol: /* Sequel */

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:10:56Z

Csgodbol: /* Sequel */

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:10:36Z

Csgodbol: /* Sequel */

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:10:14Z

Csgodbol: /* Merb */

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:09:50Z

Csgodbol: /* Merb */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

Features
Merb has set of following features:[14] 

==== Plugins ====

Plugins in Merb are implemented as simple gems. Plugins can either be installed to the system’s repository or bundled into the gems directory in an application’s distribution; Merb applications simply add the /gems folder as an alternate repository.

Plugins for Merb include support for ActiveRecord, DataMapper, and Sequel, with support for SQL sessions, model generation, and database.yml baked in to all three.

==== Controllers ====

Merb’s controllers are made up of two components. First, an AbstractController, which handles layout- and template-finding, instance variable assignment, and before/after filters. Second, a Merb::Controller, which handles request/response semantics.
Controllers also support excellent content-type negotiation.

==== Mailers ====

Merb’s Mailers are implemented on top of AbstractController, so you get all the default controller behavior (including templates, assigns, and before/after filters) for free in the Mailer. But instead of calling render, you call render_mail, which takes options like: render_mail :html => :foo, :text => :bar.
Mailers have their own root directory, which contains controller classes inside it, as well as a views directory, and an optional helpers directory.

==== Parts ====

Parts have a directory structure that’s identical to the Mailer structure, and you can use them to separate out logic about partials that are used throughout the application. Parts take advantage of the flexibility of the AbstractController to allow simple Controller/View delegation.

==== Exceptions ====

Merb handles exceptions also. Instead of exception raising throwing an error in your application, Merb catches certain types of exceptions and allows you to handle them in a controller/view fashion. For instance, raising NotFound will call the Exception#not_found action, which you can customizeas appropriate. Raising an error in this way will also send the appropriate error-code back to the browser.

==== Tests and Specs ====

Merb is testing-framework-agnostic i.e it can be used as Test::Unit, Rspec, or test/spec. All three testing frameworks have built-in support for mock objects that allows to micro-target tests exactly as desired. Merb is modular, hence it’s easy to test the controller without a request object.

==== Generators ====

Merb has a series of generators that allow you get up and running quickly. The Merb application generator is started via merb-gen app application-name. It’ll build a skeleton app that includes folders for controllers, parts, and Mailers.
Merb has controller generators, which create an empty controller file, a view directory with an empty index.html.erb, an empty helper file, and a test file in the chosen spec framework. Merb also has model generators, which are implemented by the ORM plugins, and support a special syntax: merb-gen Product name:string price_in_cents:integer which will generate a new model that implements those attributes using its own syntax. For instance, ActiveRecord would generate a migration, while DataMapper would generate new model using its property syntax.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm
*[14]http://www.merbivore.com

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T01:09:33Z

Csgodbol: /* Merb */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

Features
Merb has set of following features:[14] 

==== Plugins ====

Plugins in Merb are implemented as simple gems. Plugins can either be installed to the system’s repository or bundled into the gems directory in an application’s distribution; Merb applications simply add the /gems folder as an alternate repository.

Plugins for Merb include support for ActiveRecord, DataMapper, and Sequel, with support for SQL sessions, model generation, and database.yml baked in to all three.

==== Controllers ====

Merb’s controllers are made up of two components. First, an AbstractController, which handles layout- and template-finding, instance variable assignment, and before/after filters. Second, a Merb::Controller, which handles request/response semantics.
Controllers also support excellent content-type negotiation.

==== Mailers ====

Merb’s Mailers are implemented on top of AbstractController, so you get all the default controller behavior (including templates, assigns, and before/after filters) for free in the Mailer. But instead of calling render, you call render_mail, which takes options like: render_mail :html => :foo, :text => :bar.
Mailers have their own root directory, which contains controller classes inside it, as well as a views directory, and an optional helpers directory.

==== Parts ====

Parts have a directory structure that’s identical to the Mailer structure, and you can use them to separate out logic about partials that are used throughout the application. Parts take advantage of the flexibility of the AbstractController to allow simple Controller/View delegation.

==== Exceptions ====

Merb handles exceptions also. Instead of exception raising throwing an error in your application, Merb catches certain types of exceptions and allows you to handle them in a controller/view fashion. For instance, raising NotFound will call the Exception#not_found action, which you can customizeas appropriate. Raising an error in this way will also send the appropriate error-code back to the browser.

==== Tests and Specs ====

Merb is testing-framework-agnostic i.e it can be used as Test::Unit, Rspec, or test/spec. All three testing frameworks have built-in support for mock objects that allows to micro-target tests exactly as desired. Merb is modular, hence it’s easy to test the controller without a request object.

==== Generators ====

Merb has a series of generators that allow you get up and running quickly. The Merb application generator is started via merb-gen app application-name. It’ll build a skeleton app that includes folders for controllers, parts, and Mailers.
Merb has controller generators, which create an empty controller file, a view directory with an empty index.html.erb, an empty helper file, and a test file in the chosen spec framework. Merb also has model generators, which are implemented by the ORM plugins, and support a special syntax: merb-gen Product name:string price_in_cents:integer which will generate a new model that implements those attributes using its own syntax. For instance, ActiveRecord would generate a migration, while DataMapper would generate new model using its property syntax.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm
*[14]http://www.merbivore.com

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:55:49Z

Csgodbol: /* References */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm
*[14]http://www.merbivore.com

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:53:12Z

Csgodbol: /* References */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:51:30Z

Csgodbol: /* Sequel */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:49:52Z

Csgodbol: /* Merb */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.

Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:34:42Z

Csgodbol: /* iBATIS */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

iBATIS comes with the following design philosophies:[13] 
Simplicity: iBATIS is widely regarded as being one of the simplest persistence frameworks available today.
Fast Development: iBATIS's philosophy is to do all it can to facilitate hyper-fast development.
Portability: iBATIS can be implemented for nearly any language or platform like Java, Ruby, and C# for Microsoft .NET.
Independent Interfaces: iBATIS provides database-independent interfaces and APIs that help the rest of the application remain independent of any persistence-related resources,

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

==== Advantages of IBATIS ====

Suppports Stored procedures: iBATIS encapsulates SQL in the form of stored procedures so that business logic is kept out of the database, and the application is easier to deploy and test, and is more portable.

Supports Inline SQL: No precompiler is needed, and you have full access to all of the features of SQL.

Supports Dynamic SQL: iBATIS provides features for dynamically building SQL queries based on parameters.

Supports O/RM: iBATIS supports many of the same features as an O/RM tool, such as lazy loading, join fetching, caching, runtime code generation, and inheritance

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.
Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:31:13Z

Csgodbol: /* References */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.
Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/
*[13]http://www.tutorialspoint.com/ibatis/ibatis_quick_guide.htm

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:28:32Z

Csgodbol: /* iBATIS */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.
Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/

CSC/ECE 517 Fall 2010/ch3 3f ac

2010-10-16T00:28:07Z

Csgodbol: /* Datamapper */

= ORM for Ruby =

== Introduction ==
Object-relational mapping in computer software is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language. There are both free and commercial packages available that perform object-relational mapping, although some programmers opt to create their own ORM tools. [4] 

[[Image:ORM.png|660x660px|]]

== Advantages of ORM[2][4] ==
*ORM reduces the amount of code needed to be written.
*Facilitates implementing the Domain Model pattern.
*Changes to the object model are made in one place.
*Rich query capability. ORM tools provide an object oriented query language.
*Navigation. You can navigate object relationships transparently. Related objects are automatically loaded as needed.
*Data loads are completely configurable allowing you to load the data appropriate for each scenario.
*Concurrency support. Support for multiple users updating the same data simultaneously.
*Cache managment. Entities are cached in memory thereby reducing load on the database.
*Transaction management and Isolation.
*Key Management. Identifiers and keys are automatically propogated and managed.

== Disdvantages ==
*Most O/R mapping tools do not perform well during bulk deletions of data and particularly complex or even simple joins.
*Stored procedures may have better performance, but are not portable.
*In addition, heavy reliance on ORM software has been pointed to as a major factor in producing poorly designed databases.

== List of ORM software for Ruby ==
*ActiveRecord, part of Ruby on Rails & Open Source
*Datamapper, MIT license
*iBATIS, free open source
*Sequel, free open source
*Merb

=== ActiveRecord ===

Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.[5][11] 
Active Record‘s main contribution to the pattern is to relieve the original of two stunting problems: lack of associations and inheritance. By adding a simple domain language-like set of macros to describe the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the gap of functionality between the data mapper and active record approach. A Ruby library is available which implements the object-relational mapping (ORM) design pattern. It creates a persistable domain model from business objects and database tables, where logic and data are presented as a unified package. ActiveRecord adds inheritance and associations to the pattern above, solving two substantial limitations of that pattern. A set of macros acts as a domain language for the latter, and the Single Table Inheritance pattern is integrated for the former; thus, ActiveRecord increases the functionality of the active record pattern approach to database interaction.

ActiveRecord is the default model component of the Model-view-controller web-application framework Ruby on Rails, and is also a stand-alone ORM package for other Ruby applications. In both forms, it was conceived of by David Heinemeier Hansson, and has been improved upon by a number of contributors.
Other, less popular ORMs have been released since ActiveRecord first took the stage. Gems like DataMapper and Sequel show major improvements over the original ActiveRecord framework. As a response to their release and adoption by the Rails community, Ruby on Rails v3.0 will be independent of an ORM system, so Rails users can easily plug in DataMapper or Sequel to use as their ORM of choice.

Some of the major features are given below.[11] 

==== Automated mapping between classes and tables, attributes and columns ====

Active Record objects don‘t specify their attributes directly. They infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.

<pre>
class Product < ActiveRecord::Base; end

...is automatically mapped to the table named "products", such as:

CREATE TABLE products (
id int(11) NOT NULL auto_increment,
name varchar(255),
PRIMARY KEY (id)
);

...which again gives Product#name and Product#name=(new_name)
</pre>

==== Associations between objects controlled by simple meta-programming macros ====

Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like Project has one Project Manager or Project belongs to a Portfolio. Each macro adds a number of methods to the class which are specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby‘s attr* methods. Example:

<pre>
class Project < ActiveRecord::Base
belongs_to :portfolio
has_one :project_manager
has_many :milestones
has_and_belongs_to_many :categories
end
</pre>

==== Aggregations of value objects controlled by simple meta-programming macros ====

Active Record implements aggregation through a macro-like class method called composed_of for representing attributes as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is] composed of [an] address". Each call to the macro adds a description of how the value objects are created from the attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) and how it can be turned back into attributes (when the entity is saved to the database). Example:

<pre>
class Customer < ActiveRecord::Base
composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
end
</pre>

==== Validation rules that can differ for new or existing objects ====

Active Records implement validation by overwriting Base#validate (or the variations, validate_on_create and validate_on_update). Each of these methods can inspect the state of the object, which usually means ensuring that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
Example:

<pre>
class Account < ActiveRecord::Base
validates_presence_of :subdomain, :name, :email_address, :password
validates_uniqueness_of :subdomain
validates_acceptance_of :terms_of_service, :on => :create
validates_confirmation_of :password, :email_address, :on => :create
end
</pre>

==== Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc) ====

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation).

<pre>
class Person < ActiveRecord::Base
def before_destroy # is called just before Person#destroy
CreditCard.find(credit_card_id).destroy
end
end

class Account < ActiveRecord::Base
after_find :eager_load, 'self.class.announce(#{id})'
end
</pre>

==== Observers for the entire lifecycle ====

Observer classes respond to lifecycle callbacks to implement trigger-like behavior outside the original class. This is a great way to reduce the clutter that normally comes when the model class is burdened with functionality that doesn‘t pertain to the core responsibility of the class. Example:

<pre>
class CommentObserver < ActiveRecord::Observer
def after_create(comment) # is called just after Comment#save
Notifications.deliver_new_comment("xyz@ncsu.edu", comment)
end
end
</pre>

==== Inheritance hierarchies ====

Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). Example of inheritance:

<pre>
class Company < ActiveRecord::Base; end
class Firm < Company; end
class Client < Company; end
class PriorityClient < Client; end
</pre>

==== Transactions ====

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs. So basically transaction blocks are used if there are number of statements that must be executed together or not at all. Example:

<pre>
# Database transaction
Account.transaction do
david.withdrawal(100)
mary.deposit(100)
end
</pre>

==== Reflections on columns, associations, and aggregations ====

Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. This information can, for example, be used in a form builder that took an Active Record object and created input fields for all of the attributes depending on their type and displayed the associations to other objects.

<pre>

reflection = Firm.reflect_on_association(:clients)
reflection.klass # => Client (class)
Firm.columns # Returns an array of column descriptors for the firms table
</pre>

==== Data Definitions ====

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.
# CREATE TABLE companies (
# id int(11) unsigned NOT NULL auto_increment,
# client_of int(11),
# name varchar(255),
# type varchar(100),
# PRIMARY KEY (id)
# )

Active Record automatically links the "Company" object to the "companies" table
class Company < ActiveRecord::Base
has_many :people, :class_name => "Person"
end

class Firm < Company
has_many :clients

def people_with_all_clients
clients.inject([]) { |people, client| people + client.people }
end
end

The foreign_key is only necessary because we didn‘t use "firm_id" in the data definition
class Client < Company
belongs_to :firm, :foreign_key => "client_of"
end

# CREATE TABLE people (
# id int(11) unsigned NOT NULL auto_increment,
# name text,
# company_id text,
# PRIMARY KEY (id)
# )

Active Record will also automatically link the "Person" object to the "people" table
class Person < ActiveRecord::Base
belongs_to :company
end

=== Datamapper ===

Datamapper is an object-relational mapper library written in Ruby and commonly used with Merb. It was developed to address perceived shortcomings in Ruby on Rails' ActiveRecord library.

==== Features ====

Some features of Datamapper:
eager loading of child associations to avoid (N+1) queries
lazy loading of select properties, e.g., larger fields
query chaining, and not evaluating the query until absolutely necessary (using a lazy array implementation)
an API not too heavily oriented to SQL databases.

DataMapper differentiates itself from other Ruby Object/Relational Mappers in a number of ways:[6][12] 

==== Same API for different datastores ====

DataMapper comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices.

There’s a probably incomplete list of available datamapper adapters on the github wiki with new ones getting implemented regularly. A quick github search should give you further hints on what’s currently available.

==== Works well with databases ====

With DataMapper you define your mappings in your model. Your data-store can develop independently of your models using Migrations.

To support data-stores which you don’t have the ability to manage yourself, it’s simply a matter of telling DataMapper where to look. This makes DataMapper a good choice when Working with legacy databases

<pre>
1 class Post
2 include DataMapper::Resource
3
4 # set the storage name for the :legacy repository
5 storage_names[:legacy] = 'tblPost'
6
7 # use the datastore's 'pid' field for the id property.
8 property :id, Serial, :field => :pid
9
10 # use a property called 'uid' as the child key (the foreign key)
11 belongs_to :user, :child_key => [ :uid ]
12 end

</pre>

DataMapper only issues updates or creates for the properties it knows about. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.

DataMapper has full support for Composite Primary Keys (CPK) builtin. Specifying the properties that form the primary key is easy.

<pre>
1 class LineItem
2 include DataMapper::Resource
3
4 property :order_id, Integer, :key => true
5 property :item_number, Integer, :key => true
6 end
</pre>

If we were to know an order_id/item_number combination, retrieve the corresponding line item from the datastore.

<pre>
1 order_id, item_number = 1, 1
2 LineItem.get(order_id, item_number)
3 # => [#<LineItem @orderid=1 @item_number=1>]
</pre>

==== Less need for writing migrations ====

With DataMapper, you specify the datastore layout inside your ruby models. This allows DataMapper to create the underlying datastore schema based on the models you defined. The #auto_migrate! and #auto_upgrade! methods can be used to generate a schema in the datastore that matches your model definitions.

While #auto_migrate! desctructively drops and recreates tables to match your model definitions, #auto_upgrade! supports upgrading your datastore to match your model definitions, without actually destroying any already existing data.

There are still some limitations to the operations that #auto_upgrade! can perform. We’re working hard on making it smarter, but there will always be scenarios where an automatic upgrade of your schema won’t be possible. For example, there’s no sane strategy for automatically changing a column length constraint from VARCHAR(100) to VARCHAR(50). DataMapper can’t know what it should do when the data doesn’t validate against the new tightened constraints.

In situations where neither #auto_migrate! nor #auto_upgrade! quite cut it, you can still fall back to the classic migrations feature provided by dm-migrations.

Here’s some example code that puts #auto_migrate! and #auto_upgrade! to use.

<pre>
1 require 'rubygems'
2 require 'dm-core'
3 require 'dm-migrations'
4
5 DataMapper::Logger.new($stdout, :debug)
6 DataMapper.setup(:default, 'mysql://localhost/test')
7
8 class Person
9 include DataMapper::Resource
10 property :id, Serial
11 property :name, String, :required => true
12 end
13
14 DataMapper.auto_migrate!
15
16 # ~ (0.015754) SET sql_auto_is_null = 0
17 # ~ (0.000335) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
18 # ~ (0.283290) DROP TABLE IF EXISTS `people`
19 # ~ (0.029274) SHOW TABLES LIKE 'people'
20 # ~ (0.000103) SET sql_auto_is_null = 0
21 # ~ (0.000111) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
22 # ~ (0.000932) SHOW VARIABLES LIKE 'character_set_connection'
23 # ~ (0.000393) SHOW VARIABLES LIKE 'collation_connection'
24 # ~ (0.080191) CREATE TABLE `people` (`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(50) NOT NULL, PRIMARY KEY(`id`)) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci
25 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>
26
27 class Person
28 property :hobby, String
29 end
30
31 DataMapper.auto_upgrade!
32
33 # ~ (0.000612) SHOW TABLES LIKE 'people'
34 # ~ (0.000079) SET sql_auto_is_null = 0
35 # ~ (0.000081) SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'
36 # ~ (1.794475) SHOW COLUMNS FROM `people` LIKE 'id'
37 # ~ (0.001412) SHOW COLUMNS FROM `people` LIKE 'name'
38 # ~ (0.001121) SHOW COLUMNS FROM `people` LIKE 'hobby'
39 # ~ (0.153989) ALTER TABLE `people` ADD COLUMN `hobby` VARCHAR(50)
40 # => #<DataMapper::DescendantSet:0x101379a68 @descendants=[Person]>

</pre>

==== DataMapper provides data integrity ====

DataMapper makes it easy to leverage native techniques for enforcing data integrity. The dm-constraints plugin provides support for establishing true foreign key constraints in databases that support that concept.

==== Strategic Eager Loading ====

DataMapper will only issue the very bare minimums of queries to your data-store that it needs to. For example, the following example will only issue 2 queries. Notice how we don’t supply any extra :include information.

<pre>
1 zoos = Zoo.all
2 zoos.each do |zoo|
3 # on first iteration, DM loads up all of the exhibits for all of the items in zoos
4 # in 1 query to the data-store.
5
6 zoo.exhibits.each do |exhibit|
7 # n+1 queries in other ORMs, not in DataMapper
8 puts "Zoo: #{zoo.name}, Exhibit: #{exhibit.name}"
9 end
10 end
</pre>

The idea is that you aren’t going to load a set of objects and use only an association in just one of them. This should hold up pretty well against a 99% rule.

When you don’t want it to work like this, just load the item you want in it’s own set. So DataMapper thinks ahead. We like to call it “performant by default”. This feature single-handedly wipes out the “N+1 Query Problem”.

DataMapper also waits until the very last second to actually issue the query to your data-store. For example, zoos = Zoo.all won’t run the query until you start iterating over zoos or call one of the ‘kicker’ methods like #length. If you never do anything with the results of a query, DataMapper won’t incur the latency of talking to your data-store.

==== Querying models by their associations ====

DataMapper allows you to create and search for any complex object graph simply by providing a nested hash of conditions. The following example uses a typical Customer - Order domain model to illustrate how nested conditions can be used to both create and query models by their associations.

For a complete definition of the Customer - Order domain models have a look at the Finders page.

<pre>
1 # A hash specifying one customer with one order
2 #
3 # In general, possible keys are all property and relationship
4 # names that are available on the relationship's target model.
5 # Possible toplevel keys depend on the property and relationship
6 # names available in the model that receives the hash.
7 #
8 customer = {
9 :name => 'Dan Kubb',
10 :orders => [
11 {
12 :reference => 'TEST1234',
13 :order_lines => [
14 {
15 :item => {
16 :sku => 'BLUEWIDGET1',
17 :unit_price => 1.00,
18 },
19 },
20 ],
21 },
22 ]
23 }
24
25 # Create the Customer with the nested options hash
26 Customer.create(customer)
27 # => [#<Customer @id=1 @name="Dan Kubb">]
28
29 # The same options to create can also be used to query for the same object
30 p Customer.all(customer)
31 # => [#<Customer @id=1 @name="Dan Kubb">]
</pre>

QueryPaths can be used to construct joins in a very declarative manner.

Starting from a root model, you can call any relationship by its name. The returned object again responds to all property and relationship names that are defined in the relationship’s target model.

This means that you can walk the chain of available relationships, and then match against a property at the end of that chain. The object returned by the last call to a property name also responds to all the comparison operators that we saw above. This makes for some powerful join construction!

1 Customer.all(Customer.orders.order_lines.item.sku.like => "%BLUE%")
2 # => [#<Customer @id=1 @name="Dan Kubb">]

You can even chain calls to all or first to continue refining your query or search within a scope.

==== Identity Map ====
One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact. If you run the following code in ActiveRecord you’ll see all false results. Do the same in DataMapper and it’s true all the way down.

<pre>
1 @parent = Tree.first(:conditions => { :name => 'bob' })
2
3 @parent.children.each do |child|
4 puts @parent.object_id == child.parent.object_id
5 end
</pre>

This makes DataMapper faster and allocate less resources to get things done.

==== Lazy Option ====
Columns of potentially infinite length, like Text columns, are expensive in data-stores. They’re generally stored in a different place from the rest of your data. So instead of a fast sequential read from your hard-drive, your data-store has to hop around all over the place to get what it needs.

With DataMapper, these fields are treated like in-row associations by default, meaning they are loaded if and only if you access them. If you want more control you can enable or disable this feature for any column (not just text-fields) by passing a lazy option to your column mapping with a value of true or false.

<pre>
1 class Animal
2 include DataMapper::Resource
3
4 property :id, Serial
5 property :name, String
6 property :notes, Text # lazy-loads by default
7 end
</pre>

Plus, lazy-loading of Text property happens automatically and intelligently when working with associations. The following only issues 2 queries to load up all of the notes fields on each animal:

<pre>
1 animals = Animal.all
2 animals.each do |pet|
3 pet.notes
4 end
</pre>

==== Ruby Compatibility ====

DataMapper loves Ruby and is therefore tested regularly against all major Ruby versions. Before release, every gem is explicitly tested against MRI 1.8.7, 1.9.2, JRuby and Rubinius. We’re proud to say that almost all of our specs pass on all these different implementations.

Have a look at the testing matrix for detailed information about which gems pass or fail their specs on the various Ruby implementations.

DataMapper goes further than most Ruby ORMs in letting you avoid writing raw query fragments yourself. It provides more helpers and a unique hash-based conditions syntax to cover more of the use-cases where issuing your own SQL would have been the only way to go.

For example, any finder option that are non-standard is considered a condition. So you can write Zoo.all(:name => 'Dallas') and DataMapper will look for zoos with the name of ‘Dallas’.

It’s just a little thing, but it’s so much nicer than writing Zoo.find(:all, :conditions => [ 'name = ?', 'Dallas' ]) and won’t incur the Ruby overhead of Zoo.find_by_name('Dallas'), nor is it more difficult to understand once the number of parameters increases.

<pre>
1 Zoo.first(:name => 'Galveston')
2
3 # 'gt' means greater-than. 'lt' is less-than.
4 Person.all(:age.gt => 30)
5
6 # 'gte' means greather-than-or-equal-to. 'lte' is also available
7 Person.all(:age.gte => 30)
8
9 Person.all(:name.not => 'bob')
10
11 # If the value of a pair is an Array, we do an IN-clause for you.
12 Person.all(:name.like => 'S%', :id => [ 1, 2, 3, 4, 5 ])
13
14 # Does a NOT IN () clause for you.
15 Person.all(:name.not => [ 'bob', 'rick', 'steve' ])
16
17 # Ordering
18 Person.all(:order => [ :age.desc ])
19 # .asc is the default
</pre>

==== Open Development ====
DataMapper sports a very accessible code-base and a welcoming community. Outside contributions and feedback are welcome and encouraged, especially constructive criticism. Go ahead, fork DataMapper, we’d love to see what you come up with!

Make your voice heard! Submit a ticket or patch, speak up on our mailing-list, chat with us on irc, write a spec, get it reviewed, ask for commit rights. It’s as easy as that to become a contributor.

=== iBATIS ===

iBATIS is a persistence framework which automates the mapping between SQL databases and objects in Java, .NET, and Ruby on Rails. iBatis for Ruby (RBatis) is a port of Apache's iBatis library to Ruby and Ruby on Rails. It is an O/R-mapper that allows for complete customization of SQL. [8][9] 
Other persistence frameworks such as Hibernate allow the creation of an object model by the user, and create and maintain the relational database automatically. iBatis takes the reverse approach: the developer starts with an SQL database and iBatis automates the creation of the objects.
Both approaches have advantages, and iBatis is a good choice when the developer does not have full control over the SQL database schema. For example, an application may need to access an existing SQL database used by other software, or access a new database whose schema is not fully under the application developer's control, such as when a specialized database design team has created the schema and carefully optimized it for high performance.

Essentially, iBatis is a very lightweight persistence solution that gives most of the semantics of an O/R Mapping toolkit. In other words ,iBATIS makes it easy for the development of data-driven applications by abstracting the low-level details involved in database communication (loading a database driver, obtaining and managing connections, managing transaction semantics, etc.), as well as providing higher-level ORM capabilities (automated and configurable mapping of objects to SQL calls, data type conversion management, support for static queries as well as dynamic queries based upon an object's state, mapping of complex joins to complex object graphs, etc.). iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
Simplicity is the key advantage of iBATIS over other frameworks and object relational mapping tools.

=== Merb ===

Merb, short for "Mongrel+Erb", is a model-view-controller web framework written in Ruby. Merb adopts an approach that focuses on essential core functionality, leaving most functionality to plugins. Merb is merged into Rails web framework since December 23, 2008.Merb were merged with Rails as part of the Ruby on Rails 3.0 release.[10] 
The Merb project was started as a "clean-room" implementation of the Ruby on Rails controller stack, but has grown to incorporate a number of ideas which deviated from Rails's spirit and methodology, most notably, component modularity, extensible API design, and vertical scalability. Most of these capabilities have since been incorporated back into Rails during the Rails/Merb merger announced on December 23, 2008.
Like Rails, Merb can also be used to write sophisticated applications and RESTful Web services. It has been suggested that Merb is more flexible and faster than Rails.

=== Sequel ===

Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.It supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.Currently it has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, and Swift.[7] 

==== Sequel Example ====

<pre>
require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
primary_key :id
String :name
Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"
</pre>

= References =

*[1]Russ Olsen, Book on Design Patterns in Ruby
*[2]Chris Richardson, "ORM in dynamic languages", http://portal.acm.org/citation.cfm?id=1498765.1498783
*[3]Dr Bruce Scharlau, Paper-Teaching Ruby on Rails
*[4]http://en.wikipedia.org/wiki/Object-relational_mapping
*[5]http://en.wikipedia.org/wiki/ActiveRecord_(Rails)#Implementations
*[6]http://en.wikipedia.org/wiki/Datamapper
*[7]http://sequel.rubyforge.org/
*[8]http://ibatis.apache.org/docs/ruby/
*[9]http://en.wikipedia.org/wiki/IBATIS
*[10]http://en.wikipedia.org/wiki/Merb
*[11]http://ar.rubyonrails.org/
*[12]http://datamapper.org/