//---singleton--------------------------------------------------------
//   creational design pattern
//   ---intent
//      ensure one instance of a class with a global point of access
//   ---benefits
//      the sole instance of a class may vary
//   ---applicability-------------------------------------------------
//      one instance of a class
//         accessible to clients from a well-known access point
//         extensible by subclassing
//            extended instance should be good without changing the code
//   ---structure
//                          |       singleton       |
//                          |-----------------------|
//                          |static instance()      |
//                          | return uniqueinstance |
//                          |singletonoperation()   |
//                          |getsingletondata()     |
//                          |-----------------------|
//                          |static uniqueinstance  |
//                          |singletondata          |
//
#include <SRC\Patterns\Patterns.mqh>
namespace Singleton
{
//---participants-----------------------------------------------------
class Singleton
//   instance method
//      lets clients access its unique instance
//      class operation
//         static member function in c++
//   own unique instance may be created
  {
public:
   static Singleton* Instance();
   void              SingletonOperation();
   string            GetSingletonData();
protected:
                     Singleton();
   static Singleton* uniqueInstance;
   string            singletonData;
  };
Singleton::Singleton(void) {} //constructor
Singleton* Singleton::uniqueInstance=NULL; //static member
void Singleton::SingletonOperation(void) //operation
  {
   Print("Setting singleton data");
   singletonData="Singleton data";
  }
string Singleton::GetSingletonData(void) //get data
  {
   Print("Reading singleton data");
   return singletonData;
  }
Singleton* Singleton::Instance(void) //get instance
  {
   if(!CheckPointer(uniqueInstance))
      uniqueInstance=new Singleton;
   return uniqueInstance;
  }
//---participants-----------------------------------------------------
class Client:public ClientExample
  {
public:
   string            Output();
   void              Run();
  };
string Client::Output() {return __FUNCTION__;}
//---collaborations---------------------------------------------------
void Client::Run() //clients access a singleton solely through instance()
  {
   Singleton* instance1=Singleton::Instance();
   Singleton* instance2=Singleton::Instance();
   string compareInstances=(instance1==instance2)?
                           "Instances are the same objects":
                           "Instances are different objects";
   Print(compareInstances);
//---
   instance1.SingletonOperation();
   string singletonData=instance2.GetSingletonData();
   Print(singletonData);
//---
   delete instance1;
  }
}
//---output-----------------------------------------------------------
//   creational::singleton::client::output
//   instances are the same objects
//   setting singleton data
//   reading singleton data
//   singleton data
//---consequences-----------------------------------------------------
//   ---controlled access to sole instance
//   ---reduced name space
//      better than global variables
//   ---operations and representation
//      can be changed
//      may be subclassed
//   ---variable number of instances is ok
//   ---static methods
//      more flexible than class operations
//      but non-virtual and non-polymorphic
//---implementation---------------------------------------------------
//   ---ensuring a unique instance
//      in c++
//         static member _instance
//            pointer to its unique instance
//         static instance()
//            lazy initialization 
//               create and store on first access
//            singleton subclass pointer to _instance can be assigned
//         constructor is protected
//   ---subclassing the singleton
//      singleton is determined in instance()
//         possible singletons are hard-wired
//      instance() implementation
//         in subclass, not in parent class
//            choice of singletons at link-time is fixed
//      registry of singletons
//         register themselves by name in constructor
//            static singleton is defined in the implementation file
//            all possible singletons must be created
//               else they won't get registered
//         map between string names and singletons
//         instance() asks for the singleton by name
//         looks up the singleton
//         returns if it exists
//---related patterns-------------------------------------------------
//   abstract factory, builder, prototype 
//      can be implemented using the singleton
//+------------------------------------------------------------------+