CS 596: Client-Server Programming
Spring Semester, 1997
Doc 10, Prototype

Doc 10, Prototype Slide # 1

Doc 10, Prototype Slide # 2

Prototype

Intent

• when the classes to instantiate are specified at run time; or

• to avoid building a class hierarchy of factories that parallels the class hierarchy of products; or

• when instances of a class can have one of only a few different combinations of state. It may be easier to have the proper number of prototypes and clone them rather than instantiating the class manually each time
  

Doc 10, Prototype Slide # 3

class Prototype
     {
     public Prototype clone() 
          {
          code to make a copy of current Prototype object
          return clone;
          }

          // add what ever else you want the class to do
     }


class Protoplasm extends  Prototype
     {
     public Prototype clone() 
          {
          code to make a copy of current Protoplasm object
          return clone;
          }

     // add more other stuff
     }

ClientCodeMethod( Prototype example )
     {
     Prototype myCopy = example.clone();

     // do some work using myCopy
     }

Doc 10, Prototype Slide # 4

Cloning Issues

How to in C++ - Copy Constructors

class Door 
     {
     public:
          Door();
          Door( const Door&);

          virtual Door* clone() const;

          virtual void Initialize( Room*, Room* );
          // stuff not shown
     private:
          Room* room1;
          Room* room2;
     }

Door::Door ( const Door& other ) //Copy constructor
     {
     room1 = other.room1;
     room2 = other.room2;
     }

Door* Door::clone()  const 
     {
     return new Door( *this );
     }

Doc 10, Prototype Slide # 5

Creates a clone of the object. A new instance is allocated and a bitwise clone of the current object is place in the new object.

Returns:

a clone of this Object.

If there is not enough memory.

Object explicitly does not want to be cloned, or it does not support the Cloneable interface.

class Door implements Cloneable 
     {
     public void Initialize( Room a, Room b) 
          { room1 = a; room2 = b; }

     public Object clone() throws
                          CloneNotSupportedException
          {
          return super.clone();
          }

     Room room1;
     Room room2;
     }

Doc 10, Prototype Slide # 6

Shallow Copy Verse Deep Copy

Doc 10, Prototype Slide # 7

---

Doc 10, Prototype Slide # 8

Example of Prototype

JavaServer handles the network connection.

Algorithm:

Wait for client to connect

Open connection

Create IO streams to client

Create Server Engine to handle request

Let engine handle the request

JavaServer will want to multiple copies of server engine to handle more than one client at a time

Would like to write JavaServer just once and use it for all possible different server engines

Doc 10, Prototype Slide # 9

class JavaServer
     {
     ServerSocket acceptor;
     
     public JavaServer( int portNumber ) 
          {
          acceptor = new ServerSocket( portNumber );
          }

     public void run()
          {
          while (true)
               {
               Socket client = acceptor.accept();
               InputStream cin = client.getInputStream();
               OutputStream cout = client.getOutputStream();
               processClientRequest( cin, cout );
               }
          }

     private void processClientRequest( InputStream cin,
                                         OutputStream cout )
          {
          DateServer  handler = new DateServer( cin, cout);
          handler.processClientRequest();
          }
     }

Doc 10, Prototype Slide # 10

class AirlineReservationJavaServer extends JavaServer
     {
     ServerSocket acceptor;
     
     public AirlineReservationServer( int portNumber ) 
          {
          super( portNumber );
          }


     private void processClientRequest( InputStream cin,
                                         OutputStream cout )

          AirlineReservation  handler;
          handler = new AirlineReservation( cin, cout );
          handler.processClientRequest();
          }
     }

Doc 10, Prototype Slide # 11

Declare variables to be instances of the abstract class not instances of particular classes

Doc 10, Prototype Slide # 12

interface ServerEngine
     {
     public ServerEngine clone( InputStream in, 
                                        OutputStream out );

     public void processClientRequest();
     }

---

Doc 10, Prototype Slide # 13

JavaSever With Interface and Prototype
For Any Server

class JavaServer
     {
     ServerSocket acceptor;
     ServerEngine serverPrototype;
     
     public JavaServer( int portNumber, ServerEngine aCopy) 
          {
          acceptor = new ServerSocket( portNumber );
          serverPrototype = aCopy;
          }

     public void run() {
          while (true)
               {
               Socket client = acceptor.accept();
               InputStream cin = client.getInputStream();
               OutputStream cout = client.getOutputStream();
               processClientRequest( cin, cout );
               }
          }

     private void processClientRequest( InputStream cin,
                                         OutputStream cout )
          {
          ServerEngine  handler;
          handler = serverPrototype.clone( cin, cout);
          handler.processClientRequest();
          }
     }
Doc 10, Prototype Slide # 14

class DriverProgram
     {
     public  static  void  main( String  args[] )
          {
          ServerEngine aFactory = new DateServer();
          JavaServer  networkListener;
          networkListener = new JavaServer( 6666,  aFactory );
          networkListener.run();
          }
     }

Doc 10, Prototype Slide # 15

Consequences

• Adding and removing products at run-time

• Specifying new objects by varying values

• Specifying new objects by varying structure

• Reducing subclassing (from factory method)

• Configuring an application with classes dynamically
  

Implementation Issues

• Using a prototype manager

• Implementing the Clone operation

• Initializing clones