/////////////////////////////////////////////////////////////////////
// testSmartPtr.cpp - Demonstrates basic functionality of          //
//                    Loki::SmartPtr<T,.....>                      //
//                                                                 //
// Loki is a template-based library developed by the author of:    //
// Modern C++ Design, Andrei Alexandrescu, Addison-Wesley, 2001    //
//                                                                 //
// Jim Fawcett, CSE687 - Object Oriented Design, Spring 2004       //
/////////////////////////////////////////////////////////////////////
// Required Files:                                                 //
//   TestSmartPtr.cpp, SmartPtr.h, Singleton.h, Singleton.cpp,     //
//   SmallObj.h, SmallObj.cpp, static_check.h, Threads.h,          //
//   TypeManip.h                                                   //
/////////////////////////////////////////////////////////////////////
//
//    template
//    <
//        typename T,
//        class OwnershipPolicy = RefCounted,
//        class ConversionPolicy = DisallowConversion,
//        class CheckingPolicy = AssertCheck,
//        class StoragePolicy = DefaultSPStorage
//    >
//    class SmartPtr;
//
//    OwnershipPolicies: 
//      RefCounted          - default
//      RefCountedMT        - thread safe
//      COMRefCounted       - Adapts COM reference counting
//      RefLinked           - ??
//      DestructiveCopy     - transfers ownership
//      NoCopy              - disallows copying
//
//    ConversionPolicies:
//      AllowConversion     - allows conversion from SmartPtr to Pointee Type
//      DisallowConversion  - does not allow conversion
//
//    CheckingPolicies:
//      NoCheck             - does not check before dereference
//      AssertCheck         - asserts on null pointer
//      AssertCheckStrict   - asserts on null pointer dereference, initialization
//      RejectNullStatic    - ??
//      RejectNullStrict    - ??
//
//    StoragePolicy:
//      DefaultSPStorage    - default storage

#include <vector>
#include <string>
#include <iostream>
#include "SmartPtr.h"
using namespace Loki;

//
/////////////////////////////////////////////////////////////////////
// Wrapper that announces construction and destruction
//
template <typename T>
class WrappingAnnunciator
{
public:
  WrappingAnnunciator(const T& t);
  WrappingAnnunciator(const WrappingAnnunciator<T>& wa);
  ~WrappingAnnunciator();
  WrappingAnnunciator<T>* Clone();
  T& value();
private:
  T _t;
};

template <typename T>
WrappingAnnunciator<T>::WrappingAnnunciator(const T&t) : _t(t)
{ 
  std::cout << "\n  created"; 
}

template <typename T>
WrappingAnnunciator<T>::WrappingAnnunciator(const WrappingAnnunciator<T>& wa)
                      : _t(wa._t) { std::cout << "\n  copied"; }

template <typename T>
WrappingAnnunciator<T>::~WrappingAnnunciator() 
{ 
  std::cout << "\n  destroyed";
}

template <typename T>
T& WrappingAnnunciator<T>::value() 
{ 
  return _t;
}

template <typename T>
WrappingAnnunciator<T>* WrappingAnnunciator<T>::Clone() { 
  return new WrappingAnnunciator<T>(*this); 
}

//
/////////////////////////////////////////////////////////////////////
// Demonstration
//   Experiment with the following:
//   1. run with default Ownership ==> reference counting
//   2. run with Deep Copy Ownership
//   3. comment out the vec.reserve(20) to see LOTS of copies
//      due to reallocations during push_backs

void main()
{
  std::cout << "\n  Testing Loki::SmartPtr<T,...> "
            << "\n ===============================\n";

  typedef WrappingAnnunciator<std::string> WA;
  ///////////////////////////////////////////////////////////////////
  // Deep Copy Ownership Policy
  //
  //typedef SmartPtr< WA, WrapTemplate<DeepCopy> > SP;  // deep copy
  //std::cout << "\n  using SmartPointer<T> with DeepCopy\n";

  ///////////////////////////////////////////////////////////////////
  // Reference Counted Ownership Policy (default)
  //
  typedef SmartPtr< WA > SP;                          // reference counted
  std::cout << "\n  using SmartPointer<T> with Reference Counting\n";

  std::string strArray[] = { "zebra", "platypus", "arrdvark", "condor" };
  
  std::cout << "\n"
            <<"\n  Creating vector of SmartPtrs "
            << "\n ------------------------------";
  
  std::vector< SP > vec;
  vec.reserve(20);
  for(int i=0; i<4; ++i)
  {
    std::cout << "\n  create SmartPtr: ";
    SP sp(new WA(strArray[i]));
    std::cout << "\n  push onto vector: ";
    vec.push_back(sp);
  }
  std::cout << std::endl;

  for(int i=0; i<4; ++i)
    std::cout << "\n  " << (*vec[i]).value();

  std::cout << "\n"
            << "\n  Copying vector of SmartPtrs "
            << "\n -----------------------------";
  
  std::vector< SP > vecCopy = vec;

  std::cout << std::endl;
  for(int i=0; i<4; ++i)
    std::cout << "\n  " << (*vecCopy[i]).value();

  std::cout << std::endl;
}