Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-18T04:04:31Z

Abhagav: /* Difference between factory method pattern and prototype pattern */

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implements the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which object they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The 'new' operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] for the prototype design pattern on the right:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:These example have been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(29,70)" or a "new Point(2967,59789)" and the cloned object would have similar state to those prototypes. Thus we can customize the state of the objects that will be created by this design pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the [http://en.wikipedia.org/wiki/Composite_pattern Composite pattern], to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-18T03:24:02Z

Abhagav: /* Java Sample code to show prototype design pattern */

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] for the prototype design pattern on the right:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:These example have been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the [http://en.wikipedia.org/wiki/Composite_pattern Composite pattern], to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:51:16Z

Abhagav: /* Prototype Design Pattern */

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] for the prototype design pattern on the right:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:These example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the [http://en.wikipedia.org/wiki/Composite_pattern Composite pattern], to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:50:48Z

Abhagav: /* Java Sample code to show prototype design pattern */

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:These example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the [http://en.wikipedia.org/wiki/Composite_pattern Composite pattern], to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:48:32Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the [http://en.wikipedia.org/wiki/Composite_pattern Composite pattern], to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:47:12Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://www.dotnetlead.com/UML-Quick-Reference UML diagram] for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the [http://en.wikipedia.org/wiki/Composite_pattern Composite pattern], to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:45:09Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://www.dotnetlead.com/UML-Quick-Reference UML diagram] for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or [http://en.wikipedia.org/wiki/Builder_pattern Builder patterns], which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:43:41Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://www.dotnetlead.com/UML-Quick-Reference UML diagram] for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* [http://en.wikipedia.org/wiki/Abstract_factory_pattern The Abstract Factory], Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:40:51Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the [http://www.dotnetlead.com/UML-Quick-Reference UML diagram] for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:31:08Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the [http://www.dotnetlead.com/design-patterns/prototype prototype design pattern] comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:26:59Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory <ref name="msdn">http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-05.aspx </ref>.
==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:24:29Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes <ref name="differences">http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=prototypePattern </ref>.

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:21:19Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:This example has been taken from <ref name="javaprototype"></ref>
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:16:48Z

Abhagav: /* Prototype Design Pattern */

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead <ref name="codeprototype"></ref>.

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:15:35Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern <ref name="codeprototype">http://www.codeproject.com/Articles/185348/Prototype-Design-Pattern </ref> ]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-17T00:06:12Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype.<ref name="javaprototype">http://java.dzone.com/articles/intro-design-patterns-prototype </ref>
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:52:33Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

* prototypeList variable: It is the collection that stores all the prototypes
* AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number
* GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

*copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

*Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:51:08Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of [http://en.wikipedia.org/wiki/Creational_pattern creational pattern]. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML diagram] on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:
* Hide concrete classes from the client.
* Add and remove new classes (via prototypes) at runtime.
* Keep the number of classes in the system to a minimum.
* Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

* With the Composite pattern, to provide archiving.
* Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

* Flexibility is important.
* Objects can be extended in subclasses
* There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.
* A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

* The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:46:14Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:

• Hide concrete classes from the client.

• Add and remove new classes (via prototypes) at runtime.

• Keep the number of classes in the system to a minimum.

• Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

• With the Composite pattern, to provide archiving.

• Instead of the Factory Method pattern, when subclasses start proliferating.

'''Use the Factory Method pattern when'''

• Flexibility is important.

• Objects can be extended in subclasses

• There is a specific reason why one subclass would be chosen over another-this logic forms part of the Factory Method.

• A client delegates responsibilities to subclasses in parallel hierarchies.

'''Consider using this pattern instead of:'''

• The Abstract Factory, Prototype, or Builder patterns, which are more flexible (though also more complex).The Prototype pattern to store a set of objects to clone from the abstract factory [15].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:44:48Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:

• Hide concrete classes from the client.

• Add and remove new classes (via prototypes) at runtime.

• Keep the number of classes in the system to a minimum.

• Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

• With the Composite pattern, to provide archiving.

• Instead of the Factory Method pattern, when subclasses start proliferating.

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:43:45Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

'''Use the Prototype pattern when'''

You want to:

• Hide concrete classes from the client.

• Add and remove new classes (via prototypes) at runtime.

• Keep the number of classes in the system to a minimum.

• Adapt to changing structures of data at runtime.

'''Consider using this pattern:'''

• With the Composite pattern, to provide archiving.

• Instead of the Factory Method pattern, when subclasses start proliferating.

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:42:24Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

You will notice that in the factoryDoSomething method, the point that is created is initialized in the same way and cannot be customized1. The prototypeDoSomething method can create a point from any other point with any type of state assigned to it. We could have called it with a "new Point(23,85)" or a "new Point(2929,59483)" and the cloned object would have similar state to those prototypes. The, ahem, point of the matter is that we can customize the state of the objects that will be created by the prototype pattern.

Another major difference between the two patterns is the type of classes that can be created. A factory pattern will know (either through a registry or through sub classing) the various class types that can be created. The prototype pattern is not restricted to this as long as the object can be cloned. This allows the cloning of objects that are loaded dynamically from a class loader or ddl library or some other source where the class of the object is unknown either to the application or the component itself.

Lastly, a factory pattern can handle a limited set of class types efficiently but gets bogged down as the number of types increase. The more types a factory pattern can create, the more cumbersome the factory pattern becomes from the overhead of managing those classes (both in the factory itself and in creating the necessary supporting classes). If the classes that are managed by the factory pattern are a hierarchy of classes for any given implementation, that hierarchy is generally repeated for each type regardless of how similar each class is to any other implementation. If the factory pattern uses a registry of some sort, the registry becomes harder to manage and certainly consumes more resources. On the other hand, the prototype pattern does not suffer from these issues since the pattern is focused on an existing object. The pattern is very scalable as the types increase because it has no management or overhead associated to it. If a class hierarchy is involved for each implementation, the pattern becomes very efficient because it can reduce the number of redundant classes involved since any class can be simply cloned (in other words, you can mix and match classes from different types where applicable).

To sum up, a prototype pattern provides benefits over a factory pattern when the state of the objects should can be customized by the calling application, the class types are dynamically loaded or otherwise unknown or when there is a large number of class type implementations that potentially deal with a lot of similar classes [14].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:41:40Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

public void factoryDoSomething(Factory factory) {
Point pt = factory.createPoint();
... do something with the point ...
}

public void prototypeDoSomething(Point prototype) {
Point pt = (Point) prototype.clone();
... do something with the point ...
}

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:40:38Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''

The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''

The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''

The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

'''AnimalClient.java'''

The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.

Code:

AnimalCreator animalCreator = new AnimalCreator();
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
System.out.println(animalFarm[i].helloAnimal());
} // for [13]

===Difference between factory method pattern and prototype pattern===

The prototype pattern and the factory pattern are very similar in both intent and functionality. Both are creational patterns that will create objects of some interface without needing to specifically know the underlying class types.

The main difference between the two patterns however involves how objects are constructed. The factory pattern will, generally, construct an object using the same construction parameters each time. Each object will be initialized with the same state information and be roughly equivalent to each other. The prototype pattern, on the other hand, can use any clone able object that is given to it — even if those objects are of the same class type but with different state information assigned to them. Each object then becomes the prototype or template for any objects cloned from them. An example can demonstrate this:

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:39:37Z

Abhagav:

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:37:59Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an Object Oriented Programming concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''
The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

'''Chicken.java'''
The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.

Code:

public class Chicken extends Animal {

'''AnimalCreator.java'''
The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.

Code:

public Animal retrieveAnimal(String kindOfAnimal) {
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if
return null;
} // method retrieveAnimal

AnimalClient.java
The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.
Code:
01.AnimalCreator animalCreator = new AnimalCreator();
02.Animal[] animalFarm = new Animal[8];
03.animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
04.animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
05.animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
06.animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
07.animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
08.animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
09.animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
10.animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
11.for (int i= 0; i<=7; i++) {
12.System.out.println(animalFarm[i].helloAnimal());
13.} // for

[13]

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:36:34Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an Object Oriented Programming concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.

The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

===Java Sample code to show prototype design pattern===
The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses namely Sheep and Chicken. TheAnimalCreator class contains references to the two concrete prototypes. During the initialization of theAnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.

'''Animal.java'''

The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.
Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.

Code:
public Animal clone() {
Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
clonedAnimal.setDescription(description);
clonedAnimal.setNumberOfLegs(numberOfLegs);
clonedAnimal.setName(name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
} // catch
return clonedAnimal;
} // method clone

'''Sheep.java'''
The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.

Code:

public class Sheep extends Animal {

Chicken.java
The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.
Code:
public class Chicken extends Animal {

AnimalCreator.java
The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.
Code:
01.public Animal retrieveAnimal(String kindOfAnimal) {
02.if ("Chicken".equals(kindOfAnimal)) {
03.return (Animal) chicken.clone();
04.} else if ("Sheep".equals(kindOfAnimal)) {
05.return (Animal) sheep.clone();
06.} // if
07.
08.return null;
09.} // method retrieveAnimal

AnimalClient.java
The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of typeAnimal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.
Code:
01.AnimalCreator animalCreator = new AnimalCreator();
02.Animal[] animalFarm = new Animal[8];
03.animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
04.animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
05.animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
06.animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
07.animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
08.animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
09.animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
10.animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
11.for (int i= 0; i<=7; i++) {
12.System.out.println(animalFarm[i].helloAnimal());
13.} // for

[13]

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:34:11Z

Abhagav:

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:33:08Z

Abhagav:

<big>''' Factory Method pattern and the related patterns (Template, Prototype)'''</big> 

'''Factory Method'''

Factory method pattern is an Object Oriented Programming concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html </ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf </ref>

The new operator is used in languages like Java to create an object. However in this case the object creation details are not encapsulated. Factory method allows a client to request for an object so that the object creation is encapsulated. Factory method uses inheritance for object creation. The superclass has ‘placeholders’ for the steps involved in object creation. The actual details of the object creation are specified in the subclass.<ref name="sourcemakingfact">http://sourcemaking.com/design_patterns/factory_method </ref>

Use of factory method pattern makes the code more flexible to change. In factory method pattern, interface is used to create an object and the actual instantiation of objects is deferred to subclasses that implement this interface. New classes can be added that implement this interface. In this way it becomes easy to add new concrete classes with minimal changes to the classes that use these objects.[head_first_design_pattern]. Factory method can be used when a class does not know the type of objects that it needs to create. <ref name="userpagesfactory" />

=== UML Diagram for Factory Method Pattern ===
[[File:Factoryuml.JPG|650 px|thumb|right|UML Diagram for factory method pattern <ref name="userpagesfactory" />
]]
In the UML diagram on the right, Product is the interface for the type of object created by the factory method. The Product interface is implemented by ConcreteProduct. The factory method which returns an object of type Product, is declared in Creator. The factory method is overridden inside ConcreteCreator to return an instance of ConcreteProduct.

=== Code Example ===
This example has been taken from <ref name="sourcemakingfact" />

public interface ImageReader {
public DecodedImage getDecodedImage();
}
public class GifReader implements ImageReader {
public GifReader( InputStream in ) {
// check that it's a gif, throw exception if it's not, then if it is decode it.
}
public DecodedImage getDecodedImage() {
return decodedImage;
}
}
public class JpegReader implements ImageReader {
//...
}
In the example above the ImageReader interface is defined. In this interface, a method getDecodedImage is defined that should return a decoded image. However this image may have been encoded in any format for example GIFF or JPEG. Therefore the functionality of actually decoding the image is implemented inside two classes GifReader and JpegReader . In this way, the responsibility of creating objects decoded in the appropriate format has been delegated to the subclass implementing the interface.

=== Template Pattern ===
Template method pattern is used to specify the format of an algorithm. The basic skeleton of an algorithm is defined in the base class using abstract operations. Subclasses override these abstract operations in order to provide concrete behaviour. In this way, two different subclasses may have different implementations of the abstract functions, but the overall structure of the algorithm will remain same.<ref name="ootemplate">http://www.oodesign.com/template-method-pattern.html </ref>Template method pattern is a behavioural design pattern.<ref name="wikitemplate">http://en.wikipedia.org/wiki/Template_method_pattern </ref> Template method pattern helps to avoid code duplication and aids in code reuse.<ref name="userpagestemp">http://userpages.umbc.edu/~tarr/dp/lectures/Template.pdf </ref>

=== UML Diagram for Template Method Pattern ===
[[File:Template_method_implementation_-_uml_class_diagram.gif|650 px|thumb|right|UML Diagram for factory method pattern <ref name="ootemplate" /> ]]
In the UML diagram on the right, abstract primitive operations are defined for which the subclasses provide the implementation. Template method is implemented which specifies the structure of the algorithm. The primitive operations are called within this template method. The ConcreteClass provides subclass specific implementation for the primitive operations.

=== Code Example ===
This example has been taken from <ref name="userpagestemp" />

public abstract class TextDocument {
public final void printPage () {
Document document = createDocument();
document.printTextHeader();
System.out.println(document.body());
document.printTextFooter();
}
public abstract Document createDocument();
public abstract void printTextHeader();
public abstract void printTextFooter();
...
}

public class PlainTextDocumentBuilder extends TextDocument {
public PlainTextDocumentBuilder(InputStream in){
//check that it is an Plain text document or throw error
}
public Document createDocument()
{
return new PlainTextDocument();
}
public void printTextHeader () {
// Code for header plain text header here.
}
public void printTextFooter () {
// Code for header plain text footer here.
}
...
}

public class HtmlTextDocumentBuilder extends TextDocument {
public HtmlTextDocumentBuilder(InputStream in){
//check that it is an HTML text document or throw error
}
public Document createDocument()
{
return new HtmlTextDocument();
}
public void printTextHeader () {
// Code for header HTML text header here.
}
public void printTextFooter () {
// Code for header HTML text footer here.
}
...
}

In the above example, two types of text documents are processed, plain text Document and HTML text document. To print any of the document, the procedure to print the document body is the same. However the methods to print the header and the footer are different for both the documents. Therefore they are defined in the abstract class but the specialized implementation is provided in the subclass. printPage() is the template method. Two types of objects are used, PlainTextDocument and HtmlTextDocument. A Factory method createDocument() is called within the Template method printPage() for this purpose.

===Prototype Design Pattern===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it deals with as long as the concrete prototype extends or implements the prototype interface or class. The concrete prototype object is responsible for cloning itself and hence returning the cloned object.
The pattern thus enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at run-time as long as they are similar to the abstract prototype [11].
This pattern allows you to avoid expensive initialization routines when you construct objects that are very similar. Also the goal is to minimize the amount of work needed in creating new objects when the initialization routines are expensive. For example, if the initialization routine requires database queries, file look ups, or service calls and you already have other objects in the system that are very similar to the object you are constructing, then the prototype pattern comes into picture and helps you avoid those expensive initializations.

We have a look at the UML diagram for the prototype design pattern:

[[File:protypeuml.PNG|650 px|thumb|right|UML Diagram for prototype pattern]]

From the above diagram we can decipher the following things that are: PrototypeManager class is just a manager class that is used to add and retrieve prototypes by an index number; it has the following variable and methods:

• prototypeList variable: It is the collection that stores all the prototypes

• AddPrototype method: Allows you to add a prototype to the collection and assigning it an index number

• GetPrototype method: Allows you to retrieve a prototype from the collection using an index number

The IPrototype interface specifies the methods that all prototype classes must implement. It has the Clone method that returns an IPrototype interface.

The ConcretePrototype class is the actual prototype class; it implements the IPrototype interface and has the following property and method:

• copyProperty variable holds the information that is prepopulated. If the variable value is changed then the new instances created will have the new value.

• Clone method will make a copy of itself and return it. If the copyProperty is a value type (such as int or string) then we can use shallow copy. If the copyProperty is a reference type (such as an object that contains other objects) then we go for deep copy of the variable.
The key to this pattern is that you will create your first object with the expensive initializations, and then store the values as a prototype in the repository. When you need create the same object again you can just get the copy of the prototype from the repository with all the values already populated. This reduces the performance overhead [12].

==References==

<references />

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T23:31:54Z

Abhagav:

File:Protypeuml.PNG

2012-11-16T23:06:40Z

Abhagav:

CSC/ECE 517 Fall 2012/ch2b 2w36 av

2012-11-16T22:58:40Z

Abhagav:

CSC/ECE 517 Fall 2012

2012-11-16T22:05:07Z

Abhagav:

*[[CSC/ECE_517_Fall_2012/Table_Of_Contents]]
*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w5 su]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w4 aj]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w9 av]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w11 ap]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w12 mv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w18 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 wi]]
*[[CSC/ECE 517 Fall 2012/ch1 1w31 sa]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w16 br]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w23 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w24 nr]]
*[[CSC/ECE 517 Fall 2012/ch1 1w15 rt]]
*[[CSC/ECE 517 Fall 2012/ch1 1w3 pl]]
*[[CSC/ECE 517 Fall 2012/ch1 1w32 cm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w37 ss]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w67 ks]]

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w58 am]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w52 an]]
*[[CSC/ECE_517_Fall_2012/ch1b 1w38 nm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w60 ac]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w62 rb]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w29 st]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w3_sm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w30 an]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w17 pt]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w31 up]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w9 ms]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w19 is]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w26 aj]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w16 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w8 vp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w18 as]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w3 jm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w23 sr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w11_aa]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w15 rr]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w33 pv]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w20_aa]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w14_bb]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w21_ap]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w13_sm]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w4_sa]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w25_nr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w12_sv]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w7_ma]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w6_ar]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w32_mk]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w10_rc]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w70_sm]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w67_sk]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w40_sn]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w22_sk]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w-1w65_am]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w59_bc]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w60_ns]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w69_as]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w39_ka]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w36_av]]

CSC/ECE 517 Fall 2012/1w41 as

2012-10-11T03:14:27Z

Abhagav: /* Generic method definitions */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

====Generic Class Definitions====

Here is an example of a generic class:

public class Entry<K, V> {

private final K key;
private final V value;

public Entry(K k,V v) {
key = k;
value = v;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public String toString() {
return "(" + key + ", " + value + ")";
}
}

This generic class can be used in the following way:

Entry<String, String> grade440 = new Entry<String, String>("mike", "A");
Entry<String, Integer> marks440 = new Entry<String, Integer>("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);

====Generic method definitions====

Here is an example of a generic method using the generic class above:

public static <T> Entry<T,T> twice(T value) {
return new SimpleImmutableEntry<T,T>(value, value);
}

In many cases the user of the method need not indicate the type parameters, as they can be inferred:

Entry<String, String> pair = twice("Hello");

The parameters can be explicitly added if needed:

Entry<String, String> pair = this.<String>twice("Hello");

Generic methods can be defined based on given parameters.

public <T> T[] toArray(T... elements) {
return elements;
}

====Drawbacks of Generics====

*At run-time, all generic type information is lost.

*At run-time, all type parameter instances are converted to/from Object references, meaning that there is a high upcast/downcast overhead when using generics.

*All instances of generic classes have the exact same static members.

*It is not possible to throw generic exceptions (generic classes derived from Throwable).

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Metaprogramming can accomplish truly generic code, facilitating code minimization and better maintainability.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

*Compilation may become slow.

* Metaprograms can be difficult to maintain by programmers inexperienced in metaprogramming.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-11T02:46:27Z

Abhagav: /* Generic method definitions */

CSC/ECE 517 Fall 2012/1w41 as

2012-10-10T20:58:40Z

Abhagav: /* Generics */

CSC/ECE 517 Fall 2012/1w41 as

2012-10-10T20:34:43Z

Abhagav: /* Benefits: */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

====Generic Class Definitions====

Here is an example of a generic class:

public class Entry<K, V> {

private final K key;
private final V value;

public Entry(K k,V v) {
key = k;
value = v;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public String toString() {
return "(" + key + ", " + value + ")";
}
}

This generic class can be used in the following way:

Entry<String, String> grade440 = new Entry<String, String>("mike", "A");
Entry<String, Integer> marks440 = new Entry<String, Integer>("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);

====Generic method definitions====

Here is an example of a generic method using the generic class above:

public static <T> Entry<T,T> twice(T value) {
return new SimpleImmutableEntry<T,T>(value, value);
}

In many cases the user of the method need not indicate the type parameters, as they can be inferred:

Entry<String, String> pair = twice("Hello");

The parameters can be explicitly added if needed:

Entry<String, String> pair = this.<String>twice("Hello");

Generic methods can be defined based on given parameters.

public <T> T[] toArray(T... elements) {
return elements;
}

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Metaprogramming can accomplish truly generic code, facilitating code minimization and better maintainability.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

*Compilation may become slow.

* Metaprograms can be difficult to maintain by programmers inexperienced in metaprogramming.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-10T20:33:49Z

Abhagav: /* Metaprogramming: Benefits/Drawbacks */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

====Generic Class Definitions====

Here is an example of a generic class:

public class Entry<K, V> {

private final K key;
private final V value;

public Entry(K k,V v) {
key = k;
value = v;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public String toString() {
return "(" + key + ", " + value + ")";
}
}

This generic class can be used in the following way:

Entry<String, String> grade440 = new Entry<String, String>("mike", "A");
Entry<String, Integer> marks440 = new Entry<String, Integer>("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);

====Generic method definitions====

Here is an example of a generic method using the generic class above:

public static <T> Entry<T,T> twice(T value) {
return new SimpleImmutableEntry<T,T>(value, value);
}

In many cases the user of the method need not indicate the type parameters, as they can be inferred:

Entry<String, String> pair = twice("Hello");

The parameters can be explicitly added if needed:

Entry<String, String> pair = this.<String>twice("Hello");

Generic methods can be defined based on given parameters.

public <T> T[] toArray(T... elements) {
return elements;
}

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Metaprogramming can accomplish truly generic code, facilitating code minimization and better maintainability.
Readability

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

*Compilation may become slow.

* Metaprograms can be difficult to maintain by programmers inexperienced in metaprogramming.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-10T20:30:47Z

Abhagav: /* Drawbacks */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

====Generic Class Definitions====

Here is an example of a generic class:

public class Entry<K, V> {

private final K key;
private final V value;

public Entry(K k,V v) {
key = k;
value = v;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public String toString() {
return "(" + key + ", " + value + ")";
}
}

This generic class can be used in the following way:

Entry<String, String> grade440 = new Entry<String, String>("mike", "A");
Entry<String, Integer> marks440 = new Entry<String, Integer>("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);

====Generic method definitions====

Here is an example of a generic method using the generic class above:

public static <T> Entry<T,T> twice(T value) {
return new SimpleImmutableEntry<T,T>(value, value);
}

In many cases the user of the method need not indicate the type parameters, as they can be inferred:

Entry<String, String> pair = twice("Hello");

The parameters can be explicitly added if needed:

Entry<String, String> pair = this.<String>twice("Hello");

Generic methods can be defined based on given parameters.

public <T> T[] toArray(T... elements) {
return elements;
}

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

*Compilation may become slow.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-08T05:12:19Z

Abhagav: /* Generic Class Definitions */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

====Generic Class Definitions====

Here is an example of a generic class:

public class Entry<K, V> {

private final K key;
private final V value;

public Entry(K k,V v) {
key = k;
value = v;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public String toString() {
return "(" + key + ", " + value + ")";
}
}

This generic class can be used in the following way:

Entry<String, String> grade440 = new Entry<String, String>("mike", "A");
Entry<String, Integer> marks440 = new Entry<String, Integer>("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);

====Generic method definitions====

Here is an example of a generic method using the generic class above:

public static <T> Entry<T,T> twice(T value) {
return new SimpleImmutableEntry<T,T>(value, value);
}

In many cases the user of the method need not indicate the type parameters, as they can be inferred:

Entry<String, String> pair = twice("Hello");

The parameters can be explicitly added if needed:

Entry<String, String> pair = this.<String>twice("Hello");

Generic methods can be defined based on given parameters.

public <T> T[] toArray(T... elements) {
return elements;
}

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-08T05:01:02Z

Abhagav:

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

====Generic Class Definitions====

Here is an example of a generic class:

public class Entry<K, V> {

private final K key;
private final V value;

public Entry(K k,V v) {
key = k;
value = v;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public String toString() {
return "(" + key + ", " + value + ")";
}
}

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:35:12Z

Abhagav: /* Annotations applied to java code */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:33:37Z

Abhagav: /* Annotations applied to java code */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:32:52Z

Abhagav: /* Annotations applied to java code */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:31:44Z

Abhagav: /* Annotations applied to java code */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:30:29Z

Abhagav: /* Further Reading */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

 
public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1. http://c2.com/cgi/wiki?MetaProgramming

2. http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3. http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:29:25Z

Abhagav: /* Further Reading */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

 
public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1.http://c2.com/cgi/wiki?MetaProgramming

2.http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3.http://rubysource.com/ruby-metaprogramming-part-i/

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:29:03Z

Abhagav: /* References */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

 
public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

==Further Reading==

1.http://c2.com/cgi/wiki?MetaProgramming

2.http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/

3.http://rubysource.com/ruby-metaprogramming-part-i/

4.

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:13:47Z

Abhagav: /* Annotations applied to java code */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

This following example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

 
public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf

CSC/ECE 517 Fall 2012/1w41 as

2012-10-04T01:10:54Z

Abhagav: /* Benefits: */

==Introduction==
In this page, the concept of meta-programming is discussed. We first give the definition of meta-programming, along with a brief description. Next, we give an overview of the concept of meta-program in general i.e. its evolution and implementation in various languages is discussed. We then focus on the languages in which Meta -programming is prevalent namely Ruby, Java, C, C++ and Python. We then follow it up with the advantages and disadvantages of the same before concluding.

==Definition==
Meta-programming is the discipline of writing programs that represent and manipulate other programs or themselves. An established example of meta-program is a [http://en.wikipedia.org/wiki/Compiler compiler]. We can also define a meta-program as a program which generates code and writing such programs is called meta-programming.
This allows programmers to get more work done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
The ability of a programming language to be its own meta-language is called reflection or reflexivity. This reflection ability is a feature that is very valuable to facilitate meta-programming.

==Evolution of Meta-programming==
Meta-programming was first introduced in Lisp. In Lisp, instead of just programming towards the language, we usually build the language up to our program. This is where the meta-programming comes into picture. For meta-programming purpose, Lisp provides macros as a standard facility to write code that will be directly be read and compiled by the system at run time.

For [http://planet.plt-scheme.org/package-source/dherman/c.plt/3/1/planet-docs/c/index.html Meta programming in C-language],one of the popular examples is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C.

For [http://www.boostpro.com/mplbook/ Meta programming in C++], it is done with C++ templates i.e., we define the program’s content by writing code that generates it. The code is generally written in between question marks.

Similar programs exist for Java and C#. The general idea, however, is that such an approach can be used anywhere we have a formal specification for which we know how to generate code.

[http://en.wikipedia.org/wiki/Prolog Prolog], a generic purpose programming language, which uses the same data structures as the meta-programming and also provides simple clause expansions, is generally used for meta-programming.

==How Meta-programming works==
Meta-programming usually works in one of three ways. The first way is to expose the internals of the run-time engine to the programming code through [http://en.wikipedia.org/wiki/Application_programming_interface application programming interfaces] (APIs).

The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments and/or context. Thus, "programs can write programs."

The third way is to step outside the language entirely. General purpose [http://en.wikipedia.org/wiki/Program_transformation program transformation systems], which accept language descriptions and can carry out arbitrary transformations on those languages, are direct implementations of general meta-programming. This allows meta-programming to be applied to virtually any target language without regard to whether that target language has any meta-programming abilities of its own.

==Uses of Meta-programming==
Let us look at some of the uses of meta-programming:

*The major use of meta-programming is that it pre-generates the code at run-time. For example, if we are writing an application and we want a quick lookup table containing keys and values associated with the keys, we can have the program build the table at startup during runtime.

*It is the key ingredient for [http://en.wikipedia.org/wiki/Domain-specific_language Domain Specific Languages]. That is we use meta-programming to encapsulate domain-specific knowledge.

*Using meta-programming we can easily reduce the cost and time of development for a system by one order of magnitude, while improving the overall quality of the resulting code.

==Meta programming in Ruby==
Here we discuss about the implementation of meta-programming in a programming language called [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. We will also discuss about various techniques which help in implementing meta-programming. Ruby is an object-oriented and dynamic language. Ruby is also reflexive i.e., Ruby program can observe and modify its own structure and behavior at runtime. Also in Ruby, code is nothing but data and data is nothing but code. All these features of Ruby make it implement one of its most powerful features called meta-programming efficiently.
In Ruby, with this meta-programming feature, we can write code that manipulates language constructs like instance variables, classes and modules at runtime.
In Ruby, the classes (both standard classes and the classes created by us) are never closed i.e., we can always add extra methods to an existing class. All we need to do is open the class to which we want to add additional methods and then define the method we want to add. For instance, consider the following example:
a = [1, 2, 3, 4]
Here ‘a’ is an array and if we want to find the sum of all the elements of the array, we need to open the Array class and add the method to calculate the sum of the array elements.
class Array
def sum
inject{|a,x| a+x}
end
end
We can now call method product for the array.
a.sum
=> 10

In Ruby, we can show as if there were two methods with same name. With this property, we can implement the concept of meta-programming efficiently in Ruby. Suppose, we have a class called Rectangle and it has an initialize method. Here, we can now instantiate this Rectangle by two ways. That is, either by passing in the coordinates of its corners or by passing in any of its corner along with the length and width of the corner. So, in this manner, even though there is only one initialize method, we can act as if there were two.
# The Rectangle constructor accepts arguments in either
# of the following forms:
class Rectangle
def initialize(*args)
if args.size < 2 || args.size > 3
puts 'Sorry wrong number of arguments passed. This method takes either 2 or 3 arguments.'
else
puts 'Correct number of arguments passed!!!'
if args.size == 2
puts 'Two arguments'
else
puts 'Three arguments'
end
end
end
end
Rectangle.new([10, 23], 4, 10)
#=> Correct number of arguements passed!!!
#=> Three arguements
Rectangle.new([10, 23], [14, 13])
#=> Correct number of arguements passed!!!
#=> Two arguements

===Singleton classes===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton classes] are one of the major properties of Ruby which make implementation of meta-programming efficient. Singleton class also called as meta-class or anonymous class is a class that acts as a proxy to the objects of a class.
In Ruby, any object will have a class of which it is an instance (the class of the object can be found by calling the method class on it). Ruby has a feature where we can add additional methods to an object. So, when this is done, a new anonymous class is created which acts as an intermediate between the object and its actual class. This intermediate class or proxy class is called as a singleton class.
We can consider the above example of array and finding the sum for this as well.

===Method aliasing===
Method aliasing is a technique used in Ruby to implement the concept of meta-programming. The technique that allows us to give aliases or new names to already existing variables, operators and methods is called as method aliasing. It can also be used to wrap an existing method effectively by intercepting any calls and injecting the desired behavior. Here the new reference or the aliasing name may not be a local, instance, constant, or class variable if we are aliasing a variable.
Using this method or technique we can perform method over riding efficiently and thereby change the behavior of an object or a class. There are two keywords in Ruby which provide this method aliasing. They are alias and alias_method. The following is the syntax for both these keywords:
alias :new :old
alias_method :new, :old
Generally we use alias to give a second name to a method or variable of a class, whereas we use alias_method when we want to assign second name to a method in a Module. So basically, alias keyword takes two arguments as we can see in the syntax. The first argument is the new name or the second name and second argument is the old name or the original name. Let us look at an example that illustrates this technique. Consider the following example:
class Array
def sum
inject {|a, x| a+x }
end
alias :newsum:sum
end
a = Array.new([1, 2, 3, 4])
a.newsum #=> 10
In this example, we are defining a new method called sum and then aliasing that method with a new name called newsum in the class Array. Now we can call this method with its alias name as above and still the method will be invoked.
This is how method aliasing can be implementing. We can notice here that, this technique can be used to add new methods and alias those methods for a given class. In this manner we can also change the behavior of the class. Also, we can call the aliasing name of a method inside another method thereby implementing method over riding concept. Consider the following example to illustrate this:
class A
def method1
puts ”This is the main method”
end
alias :method2 :method1
def method1
puts “This is not main method"
method2
end
end
a = A.new()
a.method1
=> This is not main method
=> This is main method
So, in this manner method over riding is done using method aliasing. We can thus say that method aliasing can be used to implement the concept of meta-programming.

==Meta-programming in C++==
The need for representing meta-information at compile time became apparent during the development of the C++ Standard library. The problems were solved by the traits template idiom. The first article on template meta-programming was published in 1995. The IF<> template was the first control structure in a generic form.

===Support for meta-programming===
The meta-programming support in C++ is not a designed feature but more or less abuse of C++ compiler. The code of meta-programs is quite peculiar and obscure. There are also limitations for complexity of the meta-programs set by the compilers.

===Reflection===
Different languages provide different levels of reflection. While Smalltalk allows you to directly modify classes or methods by modifying their meta-objects at runtime, Java provides a much lower lever of reflection, mainly suitable for JavaBeans component model and the Remote Method Invocation mechanism. C++ provides even less support for reflection than Java, the most important feature being runtime type-identification (RTTI). There are also reflective extensions available to C++

===Two-Level Languages===
An important concept to static meta-programming is a concept of two-level languages.
Two-level languages contain static code, which is evaluated at compile time, and dynamic code, which is compiled and later executed at runtime. ISO/ANSI C++ contains a template mechanism for defining parameterized classes and functions. This includes type and integral template parameters and partial ad full template specialization. Templates together with other C++ features constitute Turing-complete, compile time sub-language of C++ (and so C++ is a two-level language). Because the sub-language is Turing complete, there are no theoretical limits to what you can implement with it. In practice, there might be technical limitations, such as compiler limits. The main compile-time conditional construct is template specialization: The compiler has to select a matching template out of several alternatives. The compile-time looping construct is template recursion (e.g. a member of class templates used in its own definition.). The compiler has to expand such patterns recursively.
===Example===
Factorial- One of the most common examples of using static code (i.e., code executed at compile time) is computing the factorial
n! = 1. 2. 3... (n - 1). n of a natural number. A conventional C++ factorial function is as follows

int factorial(int n)
{
return (n==0)? 1: n*factorial(n-1);
}

The corresponding static code for computing the factorial at compile time is given as follows; RET is used as an abbreviation for a return statement of a conventional function. When the compiler tries to instantiate the structure template Factorial<7> (where n=7). This involves initializing the enumerator RET with Factorial<6>:: RET*7 and the compiler has to instantiate Factorial<6>::RET (and so on). The template specialization matches for n=0 (i.e. Factorial<0>).

template<int n>
struct Factorial
{
enum {RET=Factorial<n-1>::RET*n};
};
// Note: template specialization
template<>
struct Factorial<0>
{
enum{RET=1};
};
// Usage:
cout << "Factorial(7)= " << Factoral<7>::RET << endl;

==Meta-programming in JAVA==

Java meta-programming mechanisms:

* Reflection

* Generics

* Metadata annotations

===Reflection===
Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. Usually this meta-level information is modeled using the general abstraction mechanisms available in the language. Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

The following is an example in [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] using the [http://en.wikipedia.org/wiki/Java_package Java package] [http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html java.lang.reflect:]

// Without reflection
new Foo().hello();

// With reflection
Class<?> clazz = Class.forName("Foo");
clazz.getMethod("hello").invoke(clazz.newInstance());

====Uses of Reflection====
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language.

====Extensibility Features====
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

====Class Browsers and Visual Development Environments====
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

====Debuggers and Test Tools====
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

====Drawbacks of Reflection====
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations cannot be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in
sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important
consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private
fields and methods the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may
destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

===Generics===
Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at [http://javarevisited.blogspot.sg/2012/03/what-is-static-and-dynamic-binding-in.html runtime] which was quite frequent error in Java code. Generics allows Java programmer to write more robust and type-safe code.

====Hierarchy and classification====
As per Java Language Specification:

*A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.

*A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.

*An interface is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.

*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.

*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface, the interface constructor is generic.

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and cast it to an Integer.

List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.

Using generics, the above code fragment can be rewritten as follows:

List<String> v = new ArrayList<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

===Metadata Annotations===
An annotation, in the [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java computer programming language], is a special form of syntactic [http://en.wikipedia.org/wiki/Metadata metadata] that can be added to [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] source code. Classes, methods, variables, parameters and packages may be annotated. Java annotations can be [http://en.wikipedia.org/wiki/Reflection_%28computer_science%29 reflective] in that they can be embedded in [http://en.wikipedia.org/wiki/Class_%28file_format%29 class files] generated by the compiler and may be retained by the Java VM to be made retrievable at [http://en.wikipedia.org/wiki/Run-time run-time].

====Built-In Annotations====
Java defines a set of annotations that are built into the language.

====Annotations applied to java code====

*@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

*@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

*@SuppressWarnings - Instructs the compiler to suppress the [http://en.wikipedia.org/wiki/Compile_time compile time] warnings specified in the annotation parameters

Example:
This example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

 
public class Animal {

public void speak() {
}

public String getType() {
return "Generic animal";
}
}

 
public class Cat extends Animal {

@Override
public void speak() { // This is a good override.
System.out.println("Meow.");
}

@Override
public String gettype() { // throws compile warning due to mistyped name.
return "Cat";
}
}

==Metaprogramming: Benefits/Drawbacks==

===Benefits:===

*Simplicity--The biggest benefit of meta-programming is that from a code-base perspective, it keeps things really simple. Because no code is generated, your classes remain incredibly small. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.And in fact, code generation can sometimes be quite daunting for people simply because the generated code increases the size of the codebase, and thus, it would at least feel like the system would be a bit more unwieldy to manage.

*Real-time Changes--Because the analysis is done at runtime, changes to your data model can be reflected in your application at real-time. There is no need to “regenerate” your code as you would with a code generation approach. But of course, this runtime analysis does incur a cost.

*Meta-programming minimizes the code.

*Meta-programming leads to better functionality.

*Meta-programming provides less effort for programmers and reduces the maintenance effort.

*Meta code is generated at compile time. Thus, results faster programs.

===Drawbacks===

*Impossible to debug.

*Hard to trace.

*Ambiguous to some extent.

*Run-time reflection reduces performance.

==References==

1. http://blog.grahampoulter.com/2008/12/code-generation-vs-metaprogramming-in.html

2. http://www.qcodo.com/wiki/article/background/metaprogramming

3. http://code-jam.blogspot.com/2006/07/metaprogramming.html

4. http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29

5. http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html

6. http://en.wikipedia.org/wiki/Generics_in_Java

7. http://tutorials.jenkov.com/java-generics/index.html

8. http://www.tutorialspoint.com/java/java_generics.htm

9. http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

10. http://en.wikipedia.org/wiki/Java_annotation

11. http://docs.oracle.com/javaee/6/tutorial/doc/girdd.html

12. http://www.cs.tut.fi/~kk/webstuff/MetaprogrammingCpp.pdf

13. http://www.ciaranmchale.com/download/java-reflection-explained-simply-manual-8up.pdf

14. http://tutorials.jenkov.com/java-reflection/classes.html

15. http://webcourse.cs.technion.ac.il/236703/Spring2012/ho/WCFiles/7b%20-%20Reflection%20in%20Java.pdf

16. http://docs.oracle.com/javase/tutorial/reflect/index.html

17. http://en.wikipedia.org/wiki/Metaprogramming

18. http://media.pragprog.com/titles/ppmetr/introduction.pdf

19. http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf

20. http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html

21. http://en.wikipedia.org/wiki/Metaprogramming

22. http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf