CS 635: Advanced Object-Oriented Design & Programming

Doc 5, Singleton Slide # 1

References

Doc 5, Singleton Slide # 2

Singleton

Intent

Motivation

Applicability

• there must be only one instance of a class, and it must be accessible to clients from a well-known access point

• when the sole instance should be extensible by subclassing, and clients should be able to use an extended instance without modifying their code

Doc 5, Singleton Slide # 3

All parts of a program must access the same security manager

Once set a security manager cannot be changed in a program

Logging the activity of a server

All parts of the server should use the same instance of the logging system

The server should not be able to change the instance of the logging system was it has been set

Doc 5, Singleton Slide # 4

// Only one object of this class can be created
class Singleton
     {
     private static Singleton _instance = null;

     private Singleton()     { fill in the blank }

     public static Singleton getInstance()
          {
          if (  _instance == null )
                _instance = new Singleton();
          return _instance;
          }
     public void otherOperations() { blank; }
     }

class Program
     {
     public void aMethod()
          {
          X = Singleton.getInstance();
          }
     }
     

Doc 5, Singleton Slide # 5

Implementation

// Only one object of this class can be created
class Singleton
     {
     private:
          static Singleton* _instance;
          void otherOperations();

     protected:
          Singleton();

     public:
          static Singleton* getInstance();
     }

 Implementation

Singleton*  Singleton::_instance = 0;

Singleton* Singleton::getInstance()
     {
     if (  _instance == 0 )
           _instance = new Singleton;
     return _instance;
     }

Doc 5, Singleton Slide # 6

Singleton and Inheritance

Each subclass needs to be a singleton

A program can have one copy of each class

Solution

Just make each subclass a singleton

Doc 5, Singleton Slide # 7

Singleton* Singleton::getInstance()
     {
     if (  _instance == 0 )
           _instance = new SingletonSubclass;
     return _instance;
     }

Doc 5, Singleton Slide # 8

C++ Solution 1

Singleton* Singleton::getInstance()
     {
     if (  _instance == 0 )
          {
          const char* singletonStyle = getenv( "singletonStyle" );

          if ( strcmp( singletonStyle, "A" ) == 0 )
                _instance = new A;

          else if ( strcmp( singletonStyle, "B" ) == 0 )
                _instance = new B;

          else
                _instance = new Singleton;
          }

     return _instance;
     }

Doc 5, Singleton Slide # 9

class Singleton
     {
     private:
          static Singleton* _instance;

          static ListOfSingletonNamePairs _registry;
          static Singleton* getSingletonFromName( char* name);

     protected:
          Singleton();
          
     public:
          static Singleton* getInstance();
          static void Register( char* name, Singleton* registerer);
          void otherOperations();
     }

Singleton* Singleton::getInstance()
     {
     if (  _instance == 0 )
          {
          const char* singletonName = getenv( "singletonStyle" );
           _instance = getSingletonFromName(singletonName);
     return _instance;
     }

Doc 5, Singleton Slide # 10

Have the subclass constructor register!

A::A()
     {
     Singleton.Register( "A", this );
     }

Create a static instance of subclass in file that contains the subclass implementation

static A theSingleton;

Doc 5, Singleton Slide # 11

Java can not create a static instance of subclass in file that contains the subclass implementation

Protection level problem with constructor

Classes in the same package can access protected constructors

If subclass makes constructor private than even parent can not access child's constructor

Keeping Singleton classes in different package from clients allows constructors to be protected

Will give solution assuming constructors must be private
Solution when constructors can be protected is simpler

Doc 5, Singleton Slide # 12

class Example
     {
     public String toString()
          {
          return "This is a simple class";
          }
     }

class Test
     {
     public  static  void  main( String  args[] ) throws Exception
          {
          Class which = Class.forName( "Example" );
          Object whichOne = which.newInstance();
          System.out.println( whichOne.toString() );
          }
     }

Doc 5, Singleton Slide # 13

abstract class Singleton
     {
     private static Singleton _instance = null;
     
     public static void setInstance( Singleton registerer)
          {
          if ( _instance != null )
               _ instance =registerer ;
          }

     public static void setInstance( String className )
          {
          Class aSingleton = Class.forName( className );

          if ( isSubclassOfSingleton( aSingleton ) )
               {
               Class[] noArgs = new Class[0];
               Method register = 
                         aSingleton.getMethod( "register", noArgs );

               register.invoke( null, noArgs);
               }
          }

     public static Singleton getInstance()
          {
          if (  _instance == null )
                    _instance = getDefaultSingleton(); 
                         
          return _instance;
          }
     }

Doc 5, Singleton Slide # 14

class Child extends Singleton
     {
     public static void register()
          {
          Singleton.setInstance(  new Child() );
          }
          
     private Child()
          { 
          what ever you need to do;
          }
     }

Doc 5, Singleton Slide # 15

Answer - Properties

Persistent properties class. This class is basically a hashtable that can be saved/loaded from a stream. If a property is not
found, a property list containing defaults is searched. This allows arbitrary nesting.

Doc 5, Singleton Slide # 16

Structure

Participants

Defines an getInstance operation that lets clients access its unique instance

May be responsible for creating its own unique instance

Collaborations

• Controlled access to sole instance
  
• Reduced name space
  
• Permits subclassing
  
• Permits a variable number of instances
  
• More flexible than class operations

---

visitors since 12-Feb-98