#ifndef REPOSITORY_H
#define REPOSITORY_H
/////////////////////////////////////////////////////////////////////
// Repository.h - application of Singleton Pattern                 //
//                                                                 //
// Jim Fawcett, CSE776 - Design Patterns, Fall 2017                //
/////////////////////////////////////////////////////////////////////
/*
*  Repository<T, Lock> derives from SingletonBase<Lock>
*  - T is the type of data held in a Repository list
*  - Lock is a template policy that determines whether
*    Repository will be thread safe.
*  - I thought using a Singleton base class would make this implementation
*    simpler, but in retrospect, maybe not.
*/
#include "../SingletonBase/SingletonBase.h"
#include <list>

namespace SingletonRepository
{
  ///////////////////////////////////////////////////////////////////
  // Repository class
  // - template parameter T is type of data held in Repo list
  // - Lock is a locking policy

  template<typename T, typename Lock>
  class Repository : public Singleton::SingletonBase<Lock>
  {
  public:
    /*---< get pointer to singleton instance >---------------------*/
    /*
    *  - lazy load, e.g., singleton instance isn't created until
    *    we call this method
    */
    static Repository<T, Lock>* Instance()
    {
      Singleton::SingletonBase<Lock>* pTemp = Singleton::SingletonBase<Lock>::Instance();

      if (pRepo == nullptr)
      {
        // uses double check locking
        if (pRepo == nullptr)
        {
          Lock lock;
          // creating repo by copying existing base
          pRepo = new Repository(pTemp);
        }
      }
      return pRepo;
    }
    /*---< tell singleton we're done with this reference >---------*/

    void Release()
    {
      pInstance->Release();
    }
    /*---< add item to Repo list >---------------------------------*/
    /*
    *  - adds can be chained
    */
    Repository<T, Lock>& add(T t)
    {
      Lock lock;
      repoList.push_back(t);
      return *this;
    }
    /*---< retrieve copy of Repo List >----------------------------*/

    std::list<T> getList()
    {
      Lock lock;
      return repoList;
    }
    /*---< set new Repo List >-------------------------------------*/

    void setList(const std::list<T>& list)
    {
      Lock lock;
      repoList = list;
    }
  protected:
    std::list<T> repoList;
    static Repository<T, Lock>* pRepo;
    Repository(Singleton::SingletonBase<Lock>* pBase);
    ~Repository() {};
    Repository(const Repository<T, Lock>&) = delete;
  };

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

  template<typename T, typename Lock>
  Repository<T, Lock>::Repository(Singleton::SingletonBase<Lock>* pBase) 
    : SingletonBase<Lock>(*pBase) {}
}
#endif