#pragma once
///////////////////////////////////////////////////////////////////////
// RepositorySingleton.h - another application of Singleton Pattern  //
// ver 2                                                             //
// Jim Fawcett, CSE776 - Design Patterns, Fall 2017                  //
///////////////////////////////////////////////////////////////////////
/*
*  Ver 2 : 13 Sep 2017
*  - Abandons, for now, double-check locking optimization.  That turned
*    out to be trickier for C++ than I expected.
*  - The next version will reintroduce a correct version of double-check
*    locking (in SingletonBase<Lock>) if there is enough performance gain 
*    to be worth the added complexity.
*    http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/
*/
#include "../RepositoryBase/RepositoryBase.h"
#include "../SingletonBase/SingletonBase.h"

namespace Singleton
{
  //  Utilities::Log log; defined as global object in SingletonBase
  /////////////////////////////////////////////////////////////////////
  // RepositorySingleton class
  // - Derives publically from both RepositoryBase<T, Lock> and SingletonBase<Lock>
  // - This class needs some knowledge of how SingletonBase works.
  // - The important fact is that RepositoryBase<T, LocK> doesn't need to know
  //   anything about Singleton behavior.  It's in that class where all
  //   the application specific code resides, so we are factoring out
  //   Singleton behavior to make that class focus on its mission.
  //
  template<typename T, typename Lock>
  class RepositorySingleton : public RepositoryBase<T, Lock>, public SingletonBase<Lock>
  {
  public:
    static RepositorySingleton<T, Lock>* Instance()
    {
      if (SingletonBase<Lock>::pInstance == nullptr)
      {
        SingletonBase<Lock>* pBase = SingletonBase<Lock>::Instance();
        log.doLog("\n  creating instance of RepositorySingleton");
        Lock lock;
        pRepo = new RepositorySingleton<T, Lock>(pBase);
      }
      return pRepo;
    }
    void Release()
    {
      pInstance->Release();
      if (refCount == 0)
      {
        log.doLog("\n  destroying instance of RepositorySingleton");
        Lock lock;
        delete pRepo;
        pRepo = nullptr;
      }
    }
  private:
    virtual ~RepositorySingleton<T, Lock>() {}
    RepositorySingleton<T, Lock>(SingletonBase<Lock>* pSB) : SingletonBase<Lock>(*pSB) 
    {
      log.doLog("\n  created copy of SingletonBase while constructing RepositorySingleton");
    }
    RepositorySingleton<T, Lock>() = delete;
    RepositorySingleton<T, Lock>(const RepositorySingleton<T, Lock>&) = delete;
    static RepositorySingleton<T, Lock>* pRepo;
  };

  template<typename T, typename Lock>
  RepositorySingleton<T, Lock>* RepositorySingleton<T,Lock>::pRepo = nullptr;
}