///////////////////////////////////////////////////////////////
// CompRefCount.h - Demonstrate Reference Counting Helpers   //
//                                                           //
// Jim Fawcett, CSE775 - Distributed Objects, Spring 2014    //
///////////////////////////////////////////////////////////////

#include <vector>
#include <string>
#include <atomic>  // C++11

/////////////////////////////////////////////////////////////////////////
// Flexible Interface - define results and zero or more arguments
//                      in template declaration

template <typename R, typename... A>  // C++11 variadic template
struct ISearchComp
{
  virtual ~ISearchComp() {};    // Zack was right - you do need this
  virtual R search(A...) = 0;   // C++11 variadic function
  virtual ISearchComp* AddRef() = 0;
  virtual void Release() = 0;
  virtual void Verbose(bool pred=true) = 0;
};

/////////////////////////////////////////////////////////////////////////
// Reference counting wrapper - expects instance to reside on heap

template <typename T>
class AbstractRefCount : public T
{
public:
  AbstractRefCount() { 
    refCnt = 1; 
  }
  T* AddRef() { ++refCnt; return this; }
  void Release() {
    if (--refCnt == 0)
      delete this;
  }
  ~AbstractRefCount() { 
    if (verbose_)
      std::cout << "\n  destroying Reference Counted Instance"; 
  }
protected:
  bool verbose_ = false;
private:
  std::atomic<size_t> refCnt;  // Reference Counting will be thread safe
};


/////////////////////////////////////////////////////////////////////////
// Our specific Reference Counted Component

//typedef std::vector<std::string> Result;
//typedef std::string Path;
//typedef std::vector<std::string> Patterns;

using Result = std::vector<std::string>;  // C++11 aliases
using Path = std::string;
using Patterns = std::vector<std::string>;

using ISearchComponent = ISearchComp<Result, const Path&, const Patterns&>;

class SearchComp : public AbstractRefCount<ISearchComponent>
{
public:
  SearchComp() : AbstractRefCount<ISearchComponent>() {};
  Result search(const Path& path, const Patterns& patterns);
  void Verbose(bool pred=true) { verbose_ = pred;  }
  ~SearchComp();
};

/////////////////////////////////////////////////////////////////////////
// Note:
// If you Define a search interface, as done above, then 
// define another with different arguments, you don't break
// clients of the old interface.  You've defined a new 
// interface type and both the clients of the old and the new
// still work.