CS 696: Advanced OO
Spring Semester, 1997
Doc 21, Flyweight and Adapter

Doc 21, Flyweight and Adapter Slide # 1

Flyweight

The pattern can be used when all the following are true

• The program uses a large number of objects

• Storage cost are high because of the sheer quantity of objects

• The program does not use object identity

  
  MyClass* objectPtrA;
  MyClass* objectPtrB;
  
  if ( objectPtrA == objectPtrB ) //testing object identity
  
  

• Most object state can be made extrinsic

  Extrinsic state is data that is stored outside the object

  The extrinsic state is passed to the object as an argument in each method

• Many objects can be replaced by a relatively few shared objects, once the extrinsic state is removed

Doc 21, Flyweight and Adapter Slide # 2

State transitions

Start state comes first
When get user name transfer to HaveUserName state
When get correct password transfer to Authorized state

HaveUserName and Authorized states need the user name

In concurrent server we may have many (100's ) different users connected at the same time.

State creation can become expensive, so create each state once (Singleton pattern)

Each time use the state pass the user name to the state

Doc 21, Flyweight and Adapter Slide # 3

class HaveUserName extends SPopState
     {
     private HaveUserName() {};
     private static HaveUserName instance;
          
     public getInstance( )
          {
          if ( instance == null ) 
               instance = new HaveUserName();
          return instance;
          }
          
     public SPopState pass( String userName, String password )
          {
          if ( validateUser( userName, password )
               return Authorized.getInstance();
          else
               return Start.getInstance();
          }
     }

Doc 21, Flyweight and Adapter Slide # 4

Adapter

Use the Adapter pattern when you want to use an existing class and its interface does not match the one you need

Doc 21, Flyweight and Adapter Slide # 5

class OldSquarePeg
     {
     public:
          void squarePegOperation()
               { do something }
     }

class RoundPeg
     {
     public:
          void virtual roundPegOperation = 0;
     }

class PegAdapter: private OldSquarePeg, public RoundPeg
     {
     public:
          void virtual roundPegOperation()
               {
               add some corners;
               squarePegOperation();
               }
     }
     
void clientMethod()
     {
     RoundPeg* aPeg = new PegAdapter();
     aPeg->roundPegOperation();
     }

Doc 21, Flyweight and Adapter Slide # 6

class OldSquarePeg     {
     public:
          void squarePegOperation() { do something }
     }

class RoundPeg     {
     public:
          void virtual roundPegOperation = 0;
     }

class PegAdapter:  public RoundPeg     {
     private:
          OldSquarePeg* square;
          
     public:
          PegAdapter()     { square = new OldSquarePeg; }
               
          void virtual roundPegOperation()     {
               add some corners;
               square->squarePegOperation();
               }
     }
Doc 21, Flyweight and Adapter Slide # 7

The Adridecoxegate Pattern?

This makes the details differ

Adapter uses an old class in a new situation
Changes the interface of an existing object

Bridge separates an interface from its implementation so that they can vary easily and independently

Decorator adds functionality to another object without changing its interface

Proxy just controls access to an object

Strategy encapsulates an algorithm

State encapsulates state dependent behavior