Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T02:57:54Z

Vmallad:

==Introduction==
==Writing robust code==
==Assertions==
===Pre-Conditions===
===Post-Conditions===
==Class Invariants==
A [http://en.wikipedia.org/wiki/Class_invariant class invariant] is a predicate that must be true at all points during a program. This is should hold no matter what a method does in the [http://en.wikipedia.org/wiki/Class_(computer_programming) class].

Consider a stack. In a stack, the size should always be greater than 0 and less than the capacity. This should always hold. This property of a [http://en.wikipedia.org/wiki/Stack_(data_structure) stack] can neither be represented by a pre-condition nor by a post-condition. Such properties of a class are called as Class invariants.

The useful effect of class invariants in [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented software] is enhanced in the presence of [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inheritance]. Class invariants are inherited, that is, "the invariants of all the parents of a class apply to the class itself."<ref> Meyer, Bertrand. Object-Oriented Software Construction, second edition, Prentice Hall, 1997, p. 570</ref>

==Programming By Contract==

Programming by Contract is known under the name of Design by Contract™ first implemented by [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel], a programming language introduced by [http://en.wikipedia.org/wiki/Bertrand_Meyer Bertrand Meyer].It provides the programmers a way to verify that the execution of their methods does not corrupt the state of the data structures.

===Definition===

According to Bertrand Meyer,

By associating pre- and postcondition assertions with a method m,the class tells its clients1
''“If you promise to call m with pre satisfied then I, in return, promise to deliver a final state in which post is satisfied"''<ref> Meyer, Bertrand. Object-Oriented Software Construction, second edition, Prentice Hall, 1997, p. 570</ref>

In other words,
''"Basically programming by contract creates a contract between the software developer and software user - in Meyer's terms the supplier and the consumer. Every feature, or method, starts with a precondition that must be satisfied by the consumer of the routine. And each feature ends with postconditions which the supplier guarantees to be true (if and only if the preconditions were met). Also, each class has an invariant which must be satisfied after any changes to the object represented by the class. In the other words, the invariant guarantees the object is in a valid state."''<ref>http://www.cs.unc.edu/~stotts/COMP204/contract.html</ref>

===Obligations and benefits===

There are two main elements in [http://en.wikipedia.org/wiki/Software Software System]- User and Programmer. In order to understand Obligations and benefits correctly, let us first consider a metaphor and later apply that to Software. The metaphor comes from business life, where a "client" and a "supplier" agree on a "contract" which documents that:

* The supplier must provide a certain product (obligation) and is entitled to expect that the client has paid its fee (benefit).

* The client must pay the fee (obligation) and is entitled to get the product (benefit).

* Both parties must satisfy certain obligations, such as laws and regulations, applying to all contracts.<ref>http://www.eiffel.com/developers/design_by_contract.html</ref>

The metaphor relates to a Software System as below:

* The [http://en.wikipedia.org/wiki/Programmer Programmer] must provide the user with a valid outcome(obligation) and can expect that the [http://en.wikipedia.org/wiki/User_(computing) User] has given a correct and valid input(benefit).

* The [http://en.wikipedia.org/wiki/User_(computing) User] must provide a valid input(obligation) to a method and can expect the [http://en.wikipedia.org/wiki/Programmer Programmer] to give the correct output(benefit).

* Some properties such as stack size discussed earlier are satisfied by the system at all points of time.

Thus, it is not the responsibility of the Programmer to satisfy the pre-condition. In fact, if the pre-condition is not satisfied by the user, the programmer need not have to do anything. Once the pre-condition is failed, it is not the Programmers' fault even if the system crashes or gives blunders as results.

In order to gain an insight about how programming By Contract actually works, consider the webAssign example from our class:

All the students are supposed to give the tests through WebAssign. During the test process, each student is expected to write their answers in the designated text boxes and save the test no more than 4 times. This is as an obligation for the student. The student in turn is ensured that all his answers are correctly recorded and rendered to the professor for evaluation. This is a benefit for the student.

WebAssign is supposed to record the answers given by the student appropriately and render them to the professor for evaluation. This is an obligation for WebAssign. WebAssign is entitled to ensure that the user has answered in the designated text boxes and saved no more than 4 times. This is a benefit to WebAssign.

==Programming 'By Contract' in JAVA==
In JAVA, although the exact Programming by contract facility is not provided, it provides an informal "similar" kind of functionality through Programming By Assertions.

===Assertions in Java===

"An [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a statement in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language that enables you to test your assumptions about your program."<ref>http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html</ref>

Each assertion contains a [http://en.wikipedia.org/wiki/Boolean_function boolean] expression which we believe should be true. If the boolean expression does not return true, the program throws an error and the further execution of the code is terminated.

There are two forms of assertions in Java:

1. assert Expression;
Here, assert is a keyword and Expression is a Boolean expression. If the expression returns true, the method execution is continued. If the expression returns false, then an AssertionError with no much detail is thrown and the method execution is terminated.

2. assert Expression1 :Expression2;
Here, we use assert statement to provide a detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor], which uses the string representation of the value as the error's detail message.

e.g.
<pre>assert !true : "assert is not true";</pre>

The output will be:

<pre>
Exception in thread "main" java.lang.AssertionError:assert is not true
</pre>

===Example===

Consider the following requirement:

The job is to pour water in a glass. The method has to pour water in the glass assuming that glass is not full. This is a precondition and can be checked using a assert statement. After the method is called, the amount of water in the class should be greater than before. This is a postcondition and can be checked by a asseret statement. At all times, the water level should be maximum if the glass is full and should be less than maximum if the glass is not full. This is Class Invariant and is checked through a method.

<pre>
public class WaterGlass{
boolean isFull;
int water_level;
final int max_level= 10;
WaterGlass()
{
isFull = false;
water_level = 0;
}
// this is the class invariant. This always returns true
public boolean invariant()
{

return ( (this.isFull == true && water_level==max_level)|| ( this.isFull == false && water_level<max_level));

}
//this is the method pourWater
public void pourWater()
{
// Pre Condition. we check that the glass is not full before going into the method.
// If the glass is full, we print the message and stop the function execution.
assert !this.isFull : "Glass is already full. cant fill in more water";

int prev_level = this.water_level;
this.water_level= this.water_level+1;
if(this.water_level == max_level)
{
isFull=true;
}
System.out.println("the water level is " + this.water_level);

// Post Condition. we check that whenever the pre condition is met,
// the new water level is always greater than the original water level

assert this.water_level>prev_level;
}
public static void main(String[] args)
{
WaterGlass myGlass=new WaterGlass();

for(int i=0;i<=10;i++)
{
myGlass.pourWater();
System.out.println("invariant is " + myGlass.invariant());
}
}
}

</pre>

The output of this code is :

<pre>
the water level is 1
invariant is true
the water level is 2
invariant is true
the water level is 3
invariant is true
the water level is 4
invariant is true
the water level is 5
invariant is true
the water level is 6
invariant is true
the water level is 7
invariant is true
the water level is 8
invariant is true
the water level is 9
invariant is true
the water level is 10
invariant is true
Exception in thread "main" java.lang.AssertionError: Glass is already full. cant fill in more water
at WaterGlass.pourWater(WaterGlass.java:22)
at WaterGlass.main(WaterGlass.java:43)

</pre>

This is a way of implementing programming By Contract in Java.

Pre-Condition Check:

<pre>
assert !this.isFull : "Glass is already full. cant fill in more water";
</pre>

This checks if the glass is already full. If it is not full, the method executes. If it is full, the execution terminates.

Post-Condition Check:

<pre>

assert this.water_level>prev_level;
</pre>

This checks if the level of water is greater than the previous level. This should always be true given the pre-Condition is satisfied.

Class Invariant:

<pre>

public boolean invariant()
{

return ( (this.isFull == true && water_level==max_level)|| ( this.isFull == false && water_level<max_level));

}
</pre>

This checks that at any point of time during the execution of the class, if the glass is full, the water level should be maximum. If the glass is not full, the water level should be less than the maximum level.

This is an "almost similar" approach to Programming By Contract. When asked about why Java does not provide a full-fledged design-by-contract facility with preconditions, postconditions and class invariants, like the one in the Eiffel programming language, the answer is

"We considered providing such a facility, but were unable to convince ourselves that it is possible to graft it onto the Java programming language without massive changes to the Java platform libraries, and massive inconsistencies between old and new libraries. Further, we were not convinced that such a facility would preserve the simplicity that is the hallmark of the Java programming language. On balance, we came to the conclusion that a simple boolean assertion facility was a fairly straight-forward solution and far less risky. It's worth noting that adding a boolean assertion facility to the language doesn't preclude adding a full-fledged design-by-contract facility at some time in the future.

The simple assertion facility does enable a limited form of design-by-contract style programming. The assert statement is appropriate for nonpublic precondition, postcondition and class invariant checking. Public precondition checking should still be performed by checks inside methods that result in particular, documented exceptions, such as IllegalArgumentException and IllegalStateException."<ref>http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html#design-faq</ref>

==Conclusion==

To the programmers, Programming By Contract guarantees that [http://en.wikipedia.org/wiki/Software_bug bugs] will be prevented by a well defined mechanism.This is based on checks for pre-conditions. For customers, it offers a label of quality, seriousness, and a job well done.

To meet the needs of today's large-scale and mission critical applications, this unique solution is a must.<ref>http://www.eiffel.com/developers/design_by_contract.html</ref>

==References==
<references/>

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T02:57:39Z

Vmallad:

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T02:55:54Z

Vmallad:

==Introduction==
==Writing robust code==
==Assertions==
===Pre-Conditions===
===Post-Conditions===
==Class Invariants==
A [http://en.wikipedia.org/wiki/Class_invariant class invariant] is a predicate that must be true at all points during a program. This is should hold no matter what a method does in the [http://en.wikipedia.org/wiki/Class_(computer_programming) class].

Consider a stack. In a stack, the size should always be greater than 0 and less than the capacity. This should always hold. This property of a [http://en.wikipedia.org/wiki/Stack_(data_structure) stack] can neither be represented by a pre-condition nor by a post-condition. Such properties of a class are called as Class invariants.

The useful effect of class invariants in [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented software] is enhanced in the presence of [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inheritance]. Class invariants are inherited, that is, "the invariants of all the parents of a class apply to the class itself."<ref> Meyer, Bertrand. Object-Oriented Software Construction, second edition, Prentice Hall, 1997, p. 570</ref>

=Programming By Contract==

Programming by Contract is known under the name of Design by Contract™ first implemented by [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel], a programming language introduced by [http://en.wikipedia.org/wiki/Bertrand_Meyer Bertrand Meyer].It provides the programmers a way to verify that the execution of their methods does not corrupt the state of the data structures.

===Definition===

According to Bertrand Meyer,

By associating pre- and postcondition assertions with a method m,the class tells its clients1
''“If you promise to call m with pre satisfied then I, in return, promise to deliver a final state in which post is satisfied"''<ref> Meyer, Bertrand. Object-Oriented Software Construction, second edition, Prentice Hall, 1997, p. 570</ref>

In other words,
''"Basically programming by contract creates a contract between the software developer and software user - in Meyer's terms the supplier and the consumer. Every feature, or method, starts with a precondition that must be satisfied by the consumer of the routine. And each feature ends with postconditions which the supplier guarantees to be true (if and only if the preconditions were met). Also, each class has an invariant which must be satisfied after any changes to the object represented by the class. In the other words, the invariant guarantees the object is in a valid state."''<ref>http://www.cs.unc.edu/~stotts/COMP204/contract.html</ref>

===Obligations and benefits===

There are two main elements in [http://en.wikipedia.org/wiki/Software Software System]- User and Programmer. In order to understand Obligations and benefits correctly, let us first consider a metaphor and later apply that to Software. The metaphor comes from business life, where a "client" and a "supplier" agree on a "contract" which documents that:

* The supplier must provide a certain product (obligation) and is entitled to expect that the client has paid its fee (benefit).

* The client must pay the fee (obligation) and is entitled to get the product (benefit).

* Both parties must satisfy certain obligations, such as laws and regulations, applying to all contracts.<ref>http://www.eiffel.com/developers/design_by_contract.html</ref>

The metaphor relates to a Software System as below:

* The [http://en.wikipedia.org/wiki/Programmer Programmer] must provide the user with a valid outcome(obligation) and can expect that the [http://en.wikipedia.org/wiki/User_(computing) User] has given a correct and valid input(benefit).

* The [http://en.wikipedia.org/wiki/User_(computing) User] must provide a valid input(obligation) to a method and can expect the [http://en.wikipedia.org/wiki/Programmer Programmer] to give the correct output(benefit).

* Some properties such as stack size discussed earlier are satisfied by the system at all points of time.

Thus, it is not the responsibility of the Programmer to satisfy the pre-condition. In fact, if the pre-condition is not satisfied by the user, the programmer need not have to do anything. Once the pre-condition is failed, it is not the Programmers' fault even if the system crashes or gives blunders as results.

In order to gain an insight about how programming By Contract actually works, consider the webAssign example from our class:

All the students are supposed to give the tests through WebAssign. During the test process, each student is expected to write their answers in the designated text boxes and save the test no more than 4 times. This is as an obligation for the student. The student in turn is ensured that all his answers are correctly recorded and rendered to the professor for evaluation. This is a benefit for the student.

WebAssign is supposed to record the answers given by the student appropriately and render them to the professor for evaluation. This is an obligation for WebAssign. WebAssign is entitled to ensure that the user has answered in the designated text boxes and saved no more than 4 times. This is a benefit to WebAssign.

==Programming 'By Contract' in JAVA==
In JAVA, although the exact Programming by contract facility is not provided, it provides an informal "similar" kind of functionality through Programming By Assertions.

===Assertions in Java===

"An [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a statement in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language that enables you to test your assumptions about your program."<ref>http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html</ref>

Each assertion contains a [http://en.wikipedia.org/wiki/Boolean_function boolean] expression which we believe should be true. If the boolean expression does not return true, the program throws an error and the further execution of the code is terminated.

There are two forms of assertions in Java:

1. assert Expression;
Here, assert is a keyword and Expression is a Boolean expression. If the expression returns true, the method execution is continued. If the expression returns false, then an AssertionError with no much detail is thrown and the method execution is terminated.

2. assert Expression1 :Expression2;
Here, we use assert statement to provide a detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor], which uses the string representation of the value as the error's detail message.

e.g.
<pre>assert !true : "assert is not true";</pre>

The output will be:

<pre>
Exception in thread "main" java.lang.AssertionError:assert is not true
</pre>

===Example===

Consider the following requirement:

The job is to pour water in a glass. The method has to pour water in the glass assuming that glass is not full. This is a precondition and can be checked using a assert statement. After the method is called, the amount of water in the class should be greater than before. This is a postcondition and can be checked by a asseret statement. At all times, the water level should be maximum if the glass is full and should be less than maximum if the glass is not full. This is Class Invariant and is checked through a method.

<pre>
public class WaterGlass{
boolean isFull;
int water_level;
final int max_level= 10;
WaterGlass()
{
isFull = false;
water_level = 0;
}
// this is the class invariant. This always returns true
public boolean invariant()
{

return ( (this.isFull == true && water_level==max_level)|| ( this.isFull == false && water_level<max_level));

}
//this is the method pourWater
public void pourWater()
{
// Pre Condition. we check that the glass is not full before going into the method.
// If the glass is full, we print the message and stop the function execution.
assert !this.isFull : "Glass is already full. cant fill in more water";

int prev_level = this.water_level;
this.water_level= this.water_level+1;
if(this.water_level == max_level)
{
isFull=true;
}
System.out.println("the water level is " + this.water_level);

// Post Condition. we check that whenever the pre condition is met,
// the new water level is always greater than the original water level

assert this.water_level>prev_level;
}
public static void main(String[] args)
{
WaterGlass myGlass=new WaterGlass();

for(int i=0;i<=10;i++)
{
myGlass.pourWater();
System.out.println("invariant is " + myGlass.invariant());
}
}
}

</pre>

The output of this code is :

<pre>
the water level is 1
invariant is true
the water level is 2
invariant is true
the water level is 3
invariant is true
the water level is 4
invariant is true
the water level is 5
invariant is true
the water level is 6
invariant is true
the water level is 7
invariant is true
the water level is 8
invariant is true
the water level is 9
invariant is true
the water level is 10
invariant is true
Exception in thread "main" java.lang.AssertionError: Glass is already full. cant fill in more water
at WaterGlass.pourWater(WaterGlass.java:22)
at WaterGlass.main(WaterGlass.java:43)

</pre>

This is a way of implementing programming By Contract in Java.

Pre-Condition Check:

<pre>
assert !this.isFull : "Glass is already full. cant fill in more water";
</pre>

This checks if the glass is already full. If it is not full, the method executes. If it is full, the execution terminates.

Post-Condition Check:

<pre>

assert this.water_level>prev_level;
</pre>

This checks if the level of water is greater than the previous level. This should always be true given the pre-Condition is satisfied.

Class Invariant:

<pre>

public boolean invariant()
{

return ( (this.isFull == true && water_level==max_level)|| ( this.isFull == false && water_level<max_level));

}
</pre>

This checks that at any point of time during the execution of the class, if the glass is full, the water level should be maximum. If the glass is not full, the water level should be less than the maximum level.

This is an "almost similar" approach to Programming By Contract. When asked about why Java does not provide a full-fledged design-by-contract facility with preconditions, postconditions and class invariants, like the one in the Eiffel programming language, the answer is

"We considered providing such a facility, but were unable to convince ourselves that it is possible to graft it onto the Java programming language without massive changes to the Java platform libraries, and massive inconsistencies between old and new libraries. Further, we were not convinced that such a facility would preserve the simplicity that is the hallmark of the Java programming language. On balance, we came to the conclusion that a simple boolean assertion facility was a fairly straight-forward solution and far less risky. It's worth noting that adding a boolean assertion facility to the language doesn't preclude adding a full-fledged design-by-contract facility at some time in the future.

The simple assertion facility does enable a limited form of design-by-contract style programming. The assert statement is appropriate for nonpublic precondition, postcondition and class invariant checking. Public precondition checking should still be performed by checks inside methods that result in particular, documented exceptions, such as IllegalArgumentException and IllegalStateException."<ref>http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html#design-faq</ref>

==Conclusion==

To the programmers, Programming By Contract guarantees that [http://en.wikipedia.org/wiki/Software_bug bugs] will be prevented by a well defined mechanism.This is based on checks for pre-conditions. For customers, it offers a label of quality, seriousness, and a job well done.

To meet the needs of today's large-scale and mission critical applications, this unique solution is a must.<ref>http://www.eiffel.com/developers/design_by_contract.html</ref>

==References:==
<references/>

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T02:32:49Z

Vmallad:

==Introduction==
==Writing robust code==
==Assertions==
===Pre-Conditions===
===Post-Conditions===
==Class Invariants==
A [http://en.wikipedia.org/wiki/Class_invariant class invariant] is a predicate that must be true at all points during a program. This is should hold no matter what a method does in the [http://en.wikipedia.org/wiki/Class_(computer_programming) class].

Consider a stack. In a stack, the size should always be greater than 0 and less than the capacity. This should always hold. This property of a [http://en.wikipedia.org/wiki/Stack_(data_structure) stack] can neither be represented by a pre-condition nor by a post-condition. Such properties of a class are called as Class invariants.

The useful effect of class invariants in [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented software] is enhanced in the presence of [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inheritance]. Class invariants are inherited, that is, "the invariants of all the parents of a class apply to the class itself."<ref> Meyer, Bertrand. Object-Oriented Software Construction, second edition, Prentice Hall, 1997, p. 570</ref>

=Programming By Contract==

Programming by Contract is known under the name of Design by Contract™ first implemented by [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel], a programming language introduced by [http://en.wikipedia.org/wiki/Bertrand_Meyer Bertrand Meyer].It provides the programmers a way to verify that the execution of their methods does not corrupt the state of the data structures.

===Definition===

According to Bertrand Meyer,

By associating pre- and postcondition assertions with a method m,the class tells its clients1
''“If you promise to call m with pre satisfied then I, in return, promise to deliver a final state in which post is satisfied"''<ref> Meyer, Bertrand. Object-Oriented Software Construction, second edition, Prentice Hall, 1997, p. 570</ref>

In other words,
''"Basically programming by contract creates a contract between the software developer and software user - in Meyer's terms the supplier and the consumer. Every feature, or method, starts with a precondition that must be satisfied by the consumer of the routine. And each feature ends with postconditions which the supplier guarantees to be true (if and only if the preconditions were met). Also, each class has an invariant which must be satisfied after any changes to the object represented by the class. In the other words, the invariant guarantees the object is in a valid state."''<ref>http://www.cs.unc.edu/~stotts/COMP204/contract.html</ref>

===Obligations and benefits===

There are two main elements in [http://en.wikipedia.org/wiki/Software Software System]- User and Programmer. In order to understand Obligations and benefits correctly, let us first consider a metaphor and later apply that to Software. The metaphor comes from business life, where a "client" and a "supplier" agree on a "contract" which documents that:

* The supplier must provide a certain product (obligation) and is entitled to expect that the client has paid its fee (benefit).

* The client must pay the fee (obligation) and is entitled to get the product (benefit).

* Both parties must satisfy certain obligations, such as laws and regulations, applying to all contracts.<ref>http://www.eiffel.com/developers/design_by_contract.html</ref>

The metaphor relates to a Software System as below:

* The [http://en.wikipedia.org/wiki/Programmer Programmer] must provide the user with a valid outcome(obligation) and can expect that the [http://en.wikipedia.org/wiki/User_(computing) User] has given a correct and valid input(benefit).

* The [http://en.wikipedia.org/wiki/User_(computing) User] must provide a valid input(obligation) to a method and can expect the [http://en.wikipedia.org/wiki/Programmer Programmer] to give the correct output(benefit).

* Some properties such as stack size discussed earlier are satisfied by the system at all points of time.

Thus, it is not the responsibility of the Programmer to satisfy the pre-condition. In fact, if the pre-condition is not satisfied by the user, the programmer need not have to do anything. Once the pre-condition is failed, it is not the Programmers' fault even if the system crashes or gives blunders as results.

In order to gain an insight about how programming By Contract actually works, consider the webAssign example from our class:

All the students are supposed to give the tests through WebAssign. During the test process, each student is expected to write their answers in the designated text boxes and save the test no more than 4 times. This is as an obligation for the student. The student in turn is ensured that all his answers are correctly recorded and rendered to the professor for evaluation. This is a benefit for the student.

WebAssign is supposed to record the answers given by the student appropriately and render them to the professor for evaluation. This is an obligation for WebAssign. WebAssign is entitled to ensure that the user has answered in the designated text boxes and saved no more than 4 times. This is a benefit to WebAssign.

==Programming 'By Contract' in JAVA==
In JAVA, although the exact Programming by contract facility is not provided, it provides an informal "similar" kind of functionality through Programming By Assertions.

===Assertions in Java===

"An [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a statement in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language that enables you to test your assumptions about your program."<ref>http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html</ref>

Each assertion contains a [http://en.wikipedia.org/wiki/Boolean_function boolean] expression which we believe should be true. If the boolean expression does not return true, the program throws an error and the further execution of the code is terminated.

There are two forms of assertions in Java:

1. assert Expression;
Here, assert is a keyword and Expression is a Boolean expression. If the expression returns true, the method execution is continued. If the expression returns false, then an AssertionError with no much detail is thrown and the method execution is terminated.

2. assert Expression1 :Expression2;
Here, we use assert statement to provide a detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor], which uses the string representation of the value as the error's detail message.

e.g.
<pre>assert !true : "assert is not true";</pre>

The output will be:

<pre>
Exception in thread "main" java.lang.AssertionError:assert is not true
</pre>

===Example===

Consider the following requirement:

The job is to pour water in a glass. The method has to pour water in the glass assuming that glass is not full. This is a precondition and can be checked using a assert statement. After the method is called, the amount of water in the class should be greater than before. This is a postcondition and can be checked by a asseret statement.

<pre>
public class WaterGlass{
boolean isFull;
int water_level;
final int max_level= 10;
WaterGlass()
{
isFull = false;
water_level = 0;
}
// this is the class invariant. This always returns true
public boolean invariant()
{

return ( (this.isFull == true && water_level==max_level)|| ( this.isFull == false && water_level<max_level));

}
//this is the method pourWater
public void pourWater()
{
// Pre Condition. we check that the glass is not full before going into the method.
// If the glass is full, we print the message and stop the function execution.
assert !this.isFull : "Glass is already full. cant fill in more water";

int prev_level = this.water_level;
this.water_level= this.water_level+1;
if(this.water_level == max_level)
{
isFull=true;
}
System.out.println("the water level is " + this.water_level);

// Post Condition. we check that whenever the pre condition is met,
// the new water level is always greater than the original water level

assert this.water_level>prev_level;
}
public static void main(String[] args)
{
WaterGlass myGlass=new WaterGlass();

for(int i=0;i<=10;i++)
{
myGlass.pourWater();
}
}
}

</pre>
==Conclusion==
==References:==
<references/>

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T01:53:08Z

Vmallad:

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T01:31:15Z

Vmallad:

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T01:30:23Z

Vmallad:

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-16T00:35:18Z

Vmallad:

==Introduction==
==Writing robust code==
==Assertions==
===Pre-Conditions===
===Post-Conditions===
==Class Invariants==
==Programming by contract==
===Definition===
===Obligations and benefits===
==Programming 'By Contract' in JAVA==
===Examples===
==Conclusion==

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-15T18:45:21Z

Vmallad:

==Introduction==

==Writing robust code==
===Assertions===
===Exceptions===
===Programming by contract===
==Assertions==
==Class Invariants==
==Programming 'By Contract'==
===Definition===
===Obligations and benifits===
===Examples===
==Conclusion==

CSC/ECE 517 Fall 2011

2011-11-15T06:52:32Z

Vmallad:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f mm]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4b ds]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4e gs]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[CSC/ECE 517 Fall 2011/ch4 4i js]]

*[[CSC/ECE 517 Fall 2011/ch4 4f ss]]

*[[CSC/ECE 517 Fall 2011/ch4 4c dm]]

*[[CSC/ECE 517 Fall 2011/ch4 4g as]]

*[[CSC/ECE 517 Fall 2011/ch4 4g nv]]

*[[CSC/ECE 517 Fall 2011/ch4 4g ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4h kp]]

*[[CSC/ECE 517 Fall 2011/ch4 4h as]]

*[[CSC/ECE 517 Fall 2011/ch4 4j fw]]

*[[CSC/ECE 517 Fall 2011/ch4 4f rs]]

*[[CSC/ECE 517 Fall 2011/ch4 4i lc]]

*[[CSC/ECE 517 Fall 2011/ch17 5b uo]]

*[[CSC/ECE 517 Fall 2011/ch17 5b br]]

*[[CSC/ECE 517 Fall 2011/ch5 5d he]]

*[[CSC/ECE 517 Fall 2011/ch5 6d ny]]

*[[CSC/ECE 517 Fall 2011/ch6 6d sk]]

*[[CSC/ECE 517 Fall 2011/ch6 6e ch]]

*[[CSC/ECE 517 Fall 2011/ch6 6b ra]]

*[[CSC/ECE 517 Fall 2011/ch6 6c sj]]

*[[CSC/ECE 517 Fall 2011/ch6 6a am]]

*[[trial]]

Talk:CSC/ECE 517 Fall 2011

2011-11-15T06:47:56Z

Vmallad: Blanked the page

CSC/ECE 517 Fall 2011/ch6 6a am

2011-11-15T06:43:55Z

Vmallad: Created page with "test"

test

User:Vmallad

2011-11-15T06:33:51Z

Vmallad: CSC/ECE 517 Fall 2011/ch6 6a am

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A [http://javapapers.com/core-java/explain-the-java-static-modifier/ static]modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:''' In the following example,We create a class called 'SingletonClass' . In this class,we declare a private static instance variable called 'singletonObject'.The constructor of the class is also made private.A public static accessor method ,'getSingletonObject' is defined which returns the reference to the instance of the class that is stored in the private instance variable singletonObject. Note that the object is created only the first time the accessor is called. Other invocations of the method yield the same object. Also the 'clone' method of the Object class is overridden to disallow cloning. The class 'SingletonObjectDemo' gets an instance of SingletonClass by using the public accessor method.An attempt to create an object of SingletonClass using 'new' throws compilation error as the constructor is made private.
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

User:Vmallad

2011-11-15T06:28:09Z

Vmallad: Blanked the page

User:Vmallad

2011-11-15T06:27:42Z

Vmallad: asdf

Talk:CSC/ECE 517 Fall 2011

2011-11-15T06:24:50Z

Vmallad: /* ch6 6a am */ new section

== ch6 6a am ==

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A [http://javapapers.com/core-java/explain-the-java-static-modifier/ static]modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:''' In the following example,We create a class called 'SingletonClass' . In this class,we declare a private static instance variable called 'singletonObject'.The constructor of the class is also made private.A public static accessor method ,'getSingletonObject' is defined which returns the reference to the instance of the class that is stored in the private instance variable singletonObject. Note that the object is created only the first time the accessor is called. Other invocations of the method yield the same object. Also the 'clone' method of the Object class is overridden to disallow cloning. The class 'SingletonObjectDemo' gets an instance of SingletonClass by using the public accessor method.An attempt to create an object of SingletonClass using 'new' throws compilation error as the constructor is made private.
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:51:07Z

Vmallad:

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:41:11Z

Vmallad:

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:39:34Z

Vmallad:

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
</references>
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:37:41Z

Vmallad:

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-30T22:16:56Z

Vmallad:

Here we discuss about [http://en.wikipedia.org/wiki/Interface_(computing) interfaces] in [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/Mixins mixins] in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] and compare some of the functionalities offered by mixins in Ruby and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A [http://en.wikipedia.org/wiki/Module_(programming) Module] in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy. There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Examples of Modules:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules in the above example are classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality as above cannot be implemented through a class. Because to do so, we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a module's method the instance methods of our class, we have to use the ''include'' keyword instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.
Consider the same example as in modules. we now write a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace], Preci-sion, [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-30T22:07:28Z

Vmallad:

Here we discuss about [http://en.wikipedia.org/wiki/Interface_(computing) interfaces] in [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/Mixins mixins] in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] and compare some of the functionalities offered by mixins in Ruby and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A [http://en.wikipedia.org/wiki/Module_(programming) Module] in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy. There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Examples of Modules:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules in the above example are classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality as above cannot be implemented through a class. Because to do so, we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a module's method the instance methods of our class, we have to use the ''include'' keyword instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace], Preci-sion, [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to sort different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-30T20:10:20Z

Vmallad:

Here we discuss about [http://en.wikipedia.org/wiki/Interface_(computing) interfaces] in [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/Mixins mixins] in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] and compare some of the functionalities offered by mixins in Ruby and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}

}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A [http://en.wikipedia.org/wiki/Module_(programming) Module] in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy. There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Examples of Modules:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules in the above example are classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality as above cannot be implemented through a class. Because to do so, we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a module's method the instance methods of our class, we have to use the ''include'' keyword instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace], Preci-sion, [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to sort different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In this example,we define a module 'Wisher' which defines a method 'wish' which uses a method of 'name' of the host class ie the class in which we are going to include this module. Next we define the host class (Person) which includes 'Wisher'. It contains an attribute reader method 'name' and an initialize method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The wish method uses method'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends Comparable interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.

eg:
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>

* Also classes implementing interfaces do not inherit code; it is purely something to help more programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java to achieve the power of mixins,we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-30T18:54:41Z

Vmallad:

Here we discuss about [http://en.wikipedia.org/wiki/Interface_(computing) interfaces] in [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/Mixins mixins] in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] and compare some of the functionalities offered by mixins in Ruby and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}

}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy. There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Examples of Modules:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules in the above example are classes. Ruby is single-inherited, so the same functionality as above cannot be implemented through a class. Because to do so, we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a module's method the instance methods of our class, we have to use the ''include'' keyword instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic trigonometric and transcendental functions.

'''ObjectSpace''' is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called Comparable which declares an abstract method called ''CompareTo''. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to sort different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is thread-safe(multiple threads can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends Comparable interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.

eg:
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>

* Also classes implementing interfaces do not inherit code; it is purely something to help more programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For refactoring common behavior into a single place in java to achieve the power of mixins,we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T19:22:12Z

Vmallad:

Here we discuss about the interfaces in Java, mixins in Ruby and compare some of the functionalities performed by Ruby and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==Pre-defined mixin modules ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic trigonometric and transcendental functions.

'''ObjectSpace''' is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable:==
Suppose there is a requirement where we have to compare few objects and sort them. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to sort different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>
==Enumerable Behavior ==
Enumerable module
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin. 
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.
'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

'''Example''': One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 
Note: The functionality of this interface is duplicated by the Iterator interface

==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA: 
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==Singleton Behavior:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.” 
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.

Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends Comparable interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>

*Implementing interfaces does not inherit code; it is purely something to help more programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:38:58Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==Pre-defined mixin modules ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin. 
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
hasMoreElements: Tests if this enumeration contains more elements. 
nextElement: the next element of this enumeration. 
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA: 
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==Singleton Behavior:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.” 
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.

Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends Comparable interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>

*Implementing interfaces does not inherit code; it is purely something to help more programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:36:02Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin. 
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
hasMoreElements: Tests if this enumeration contains more elements. 
nextElement: the next element of this enumeration. 
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA: 
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.” 
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.

Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends Comparable interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>

*Implementing interfaces does not inherit code; it is purely something to help more programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:32:51Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin. 
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
hasMoreElements: Tests if this enumeration contains more elements. 
nextElement: the next element of this enumeration. 
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA: 
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.” 
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre
Instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.

Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends Comparable interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>

*Implementing interfaces does not inherit code; it is purely something to help more programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:26:26Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin. 
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:24:51Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:23:16Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::) 
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:20:12Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be included.
* The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class. 
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)<be >
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:16:32Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:15:09Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square 
Area is 25.0 
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:14:03Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square 
Area is 25.0 
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

</pre>
==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
<pre>
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>
==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end
</pre>
'''output:'''
<pre>
org2 is greater
</pre>
==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
'''Example:'''
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007
</pre>
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre>
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using
datamapper.setup

''' '''
<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>
DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>
==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
</pre>
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T04:01:48Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

<pre>
Drawing Square 
Area is 25.0 
</pre>

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:57:57Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
((( interface <interface name>
{ <constants>
<method declarations>
} )))
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

((( interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
})))
'''Output:'''
(((
Drawing Square 
Area is 25.0 
)))

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:55:42Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''

Drawing Square 
Area is 25.0 

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:54:54Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:''' :

Drawing Square 
Area is 25.0 

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:52:19Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
'''Output:'''
Drawing Square 
Area is 25.0 

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.

'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:48:45Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
Output: 
Drawing Square 
Area is 25.0 

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:45:57Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
Contractual Obligation
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

interface Shape
{
void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);}
}
public class InfDemo{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
Output:
Drawing Square
Area is 25.0

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-09-22T03:34:45Z

Vmallad:

==Interfaces in Java==
Interfaces in Java. An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly are implicitly public, An interface cannot be instantiated as it is incomplete ie the methods are only declared but not defined. It can only be extended by other interfaces or implemented by classes. An interface can extend any number of interfaces.
interface <interface name>
{ <constants>
<method declarations>
}
A variable whose declared type is an interface type can hold a reference to an object of a class (or its subclass) that has implemented this interface.
===Contractual Obligation===
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an abstract class if it fails to implement even one method specified in the interface. An error message is issued by the compiler if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of Interface:'''

{void draw();
void displayArea(float a,float b);
}
class Square implements Shape
{ void draw() { System.out.println(“Drawing Square”);}
void displayArea(float a,float b)
{ System.out.println(“Area is ”+a*b);}
}
Class InfDemo
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
Output: Drawing Square
Area is 25.

==Modules in Ruby==
A module in Ruby has the same implementation and is similar to class except a few significant differences:
1. Instance of a module cannot be created.
2. It cannot be inherited by other classes but can be included.
3. The syntax to define module is different.
Example: Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow. The module GoodGuy implements a method bow and tell the caller to bow to the guy because he is a good guy. There is another module BadGuy which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
'''Example of Module:'''
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end

module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end

require 'GoodGuy'
require 'BadGuy'
GoodGuy.bow
BadGuy.bow

==Mixins in Ruby==
===History of Mixins:===
Mixins are not new. Smalltalk supported them back in 1971.
Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts:[1] The ice cream shop owner offered a basic flavor of ice cream (vanilla, chocolate, etc.) and blended in a combination of extra items (nuts, cookies, fudge, etc.) and called the item a "Mix-in", his own trademarked term at the time .
===Mixins===
Lets assume for a while that the two modules in the above examples are classes. Since Ruby is single-inherited, we cannot implement the same functionality as above through a class. Because to do so, we have to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides the excellent feature of multiple inheritance. We can import the functionality of any module into our class. Thus, the features of this module gets “mixed-in” with our class.
A class cannot inherit a module but can use the functionality of it by loading it into its definition using the ‘require’ keyword. Then, we can call all the functions in this module as if they belong to our class. If there are two modules having the same method and both modules are required by our class, the name conflict is resolved by using scope resolution operator (::)
The methods of the module do not belong to the class requiring it. In order to make a modules’ method the instance methods of our class, we have to use the include keyword instead of require. However, when we try to include a module which is in a separate file, we have to use both the keywords require and include. Even now, it does not mean that these methods are copied into the class definition. It just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

'''Example of Mixins:'''
class Actnow
require 'GoodGuy'
require 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end
myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

==PRE-DEFINED MIXIN MODULES ==
Ruby has the following built into modules: Comparable, Enumerable, FileTest, GC, Kernel, Math, ObjectSpace, Preci-sion, Process, Signal

Comparable is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

Enumerable is a mix-in module for enumeration. The including class must provide the method each.

FileTest is a module containing file test functions; its methods can also be accessed from the File class.
The GC module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
Kernel is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.
Math is a module containing module functions for basic trigonometric and transcendental functions.
ObjectSpace is a module which contains routines that interact with the garbage collection facility and allows traversing all living objects with an iterator.
Precision is a mixin for concrete numeric classes with precision
==Comparable:==
Suppose there is a requirement where we have to compare two objects and determine which is greater. In Java, there is an interface called Comparable which defines in it an abstract method called CompareTo. There is no implementation of this method here. Several pre-defined classes such as Float,Double,Integer,Long implement this interface and give the definition of the CompareTo method. What if we have to compare two objects of our class by comparing a specific attribute of the objects. We need to implement the interface in our class and provide the implementation of the CompareTo method and write our code in there to compare the two objects of that class.
Consider a situation where we have a class Organization and this Organization stores the information about Organizations. Suppose we have to determine between two different organizations as to which is greater by comparing the total revenue of each. The implementation in Java is as follows.

'''Example of Comparable in Java:'''
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

Output:
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

In this implementation, we had to override the compareTo method and give implementation to determine which organization is greater. Ruby Comparable provides a much simpler approach to this problem. In Ruby, as you will see below, we just need to tell the Comparable module which attribute it has to compare to determine greater object. We need not provide implementation to compare.
'''Example of Comparable in Ruby:'''
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
if org1>org2
puts " org1 is greater"
end
if org2>org1
puts " org2 is greater"
end

output: org2 is greater

==ENUMERABLE BEHAVIOR ==
ENUMERABLE MODULE
Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and define an iterator ‘each’. This iterator has to return the elements of the collection in turn.
If the classes which have included the Enumerable module can implement the rocket method , we can also use other methods like min, max ,sort on the collections.
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable
Usage of Enumerables.
Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.
It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
Following is the list of methods provided by the Enumerable mixin.
all? ; any? ; chunk collect collect_concat count cycle detect drop drop_while each_cons each_entry each_slice each_with_index each_with_object entries find find_all find_index first flat_map grep group_by include? inject map max max_by member? min min_by minmax minmax_by none? one? partition reduce reject reverse_each select slice_before sort sort_by take take_while to_a zip

''' To Mix in Enumerable in a class,'''

Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end.
Some of the built in classes which mixin Enumerable are : String, Hash ,Array ,Range ,Struct.
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.
eg: the Array class ‘s each method yields each element.
The Hash class‘s each yields each key-value pair as a two element array.
Some Useful Methods offered by Enumerable:
map: modifies each member according to the instructions in a block and returns the modified collection of members.
.collect: similar to map.
grep: The grep method ‘searches’ for members using a regular expression
Eg: (1..10).grep (5..7) #=>[5,6,7]
find?
all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
Eg. %w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false

any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil. %w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true

EXAMPLE: One of the common and useful methods of enumerable is ‘inject’. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of Enumerable'''
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end
def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+) # output: 123007
In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example contains can be mapped to find,to_array can be mapped to collect. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

ENUMERABLE INTERFACE IN JAVA.
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
hasMoreElements: Tests if this enumeration contains more elements.
nextElement: the next element of this enumeration.
Note: The functionality of this interface is duplicated by the Iterator interface
==Data Mapper:==
In any software development, we often face situations where our code has to interact with a database. In such situations, we have to have knowledge of a query language like SQL to insert into, delete from or modify a database. In modern programming languages, a feature called Object Relational Mapping is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.
In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide features and is thread-safe(multiple threads can call it without interfering with each other.
Below are the steps involved in using the DataMapper
Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

$sudo gem install dm-core
Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter

'''''

Step 3: We then need to require the dm-core gem in our application.
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup
''' '''

DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )

Step-4 – Define models in a class using DataMapper:
''' The models can be created as below'''
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end

This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
'''the code'''
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

DataMappers in JAVA:
In java, Hibernate, iBatis are modern approaches that provide the ORM functionality. Traditionally, JDBC had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects.
Hibernate defines a language called HQL(Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by Redhat in Java to introduce ORM in Java.

==SINGLETON BEHAVIOR:==
According to Wikipedia ,” In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”
The singleton design pattern is used to have one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.
In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
1.’require’ the ‘Singleton’ and then include it in desired class.
2.Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
1. New method is made private so that it can’t be used for instantiation.
2. A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg: Usage:'''
class A
include Singleton
# ...
end
this ensures that only one instance of A be created.
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
Instance is created at the first call of A.instance(), thus

This behavior is preserved under inheritance and cloning.This is achieved by marking A.new as private
And providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by JVM.
To implement this behavior, the class’s default constructor is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.
For implementing a singleton pattern, consider the following steps:
Step -1: Provide a default private constructor.
Step-2: Define a method to obtain the reference to the singleton Object.
Step 3: The Access method has to be made synchronized to prevent Thread Problems.
Step 4: The Object clone method has to be overridden to prevent cloning

''' Example of Singleton:'''
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

==Mixin vs Interfaces==
What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:'''
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
Such a feature is not supported by interfaces in java.

Rewriting : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at run-time, the classes that include the module use the modified version of the module.
Both Java and Ruby support single inheritance.ie A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. Ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an “is-a” relationship. Mixins are used when there is a “uses a” or “has a” relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.
One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. Ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced.
Consider the comparable behavior for example. Both mixin and the interface provide similar behavior. But if a class extends ‘Comparable’ interface but fails to implement the compareTo method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the  method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? Etc then an runtime error occurs.
Also
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”.
Implementing interfaces does not inherit code; it is purely something to help more programs
type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion:==
Some of the functionality of mixins is provided by interfaces in popular languages like Java and C#. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for refactoring common behavior into a single place.
Interfaces combined with aspect-oriented programming can produce full fledged mixins in languages that support such features, such as C# or Java. Additionally, through the use of the marker interface pattern, generic programming, and extension methods

==REFERENCES:==
http://ruby.about.com/od/sinatra/a/datamapper.htm .
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html
http://www.tutorialspoint.com/ruby/ruby_modules.htm
http://www.javabeginner.com/learn-java/java-singleton-design-pattern
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm
http://ruby-doc.org/
http://download.oracle.com/javase/tutorial
http://en.wikipedia.org/wiki/Mixin
http://en.wikipedia.org/wiki/Singleton_pattern