///////////////////////////////////////////////////////////////
// Instantiation.cpp - Prototype for receiving in Project #3 //
//                                                           //
// Jim Fawcett, CSE687 - Object Oriented Design, Spring 2008 //
///////////////////////////////////////////////////////////////

#include <vector>
#include <iostream>
#include <string>

///////////////////////////////////////////////////////////
// Demonstration interface
// - shows required functionality for any of the required
//   containers

class IDemo
{
public:
  virtual void show()=0;
  virtual ~IDemo() {}
  virtual std::string& ContainerType()=0;
  virtual std::string& ValueType()=0;
  virtual size_t size()=0;
};

///////////////////////////////////////////////////////////
// class for wrapping container to implement interface
// - will need another wrapper for containers of containers

template <typename T>
class wrapper : public T, public IDemo
{
public:
  operator T& () { return *this; }
  void show()
  {
    T::iterator iter;
    std::cout << "\n  " << ContainerType();
    std::cout << "\n  " << ValueType();
    for(iter=begin(); iter!=end(); ++iter)
      std::cout << "\n  " << *iter;
    std::cout << "\n\n";
  }
  std::string& ContainerType()
  {
    return ContainerType_;
  }
  std::string& ValueType()
  {
    return ValueType_;
  }
  size_t size() { return static_cast<T*>(this)->size(); }
private:
  std::string ContainerType_;
  std::string ValueType_;
};

///////////////////////////////////////////////////////////
// ideas for building a factory on the receiving side

//----< you can use these on the sending side as well >----

enum CT { CT_vector, CT_list /* other container types */ };
enum VT { VT_double, VT_string /* other value types */ };

typedef std::vector<std::string> VofS;
typedef std::vector<double> VofD;

// other typedefs

//----< populate vector >----------------------------------

IDemo* PopulateVector(IDemo* pIDemo, VT valueType)
{
  if(valueType == VT_string)
  {
    // simulate reading from message to populate container

    wrapper<VofS>* pWVS = dynamic_cast< wrapper<VofS>* >(pIDemo);
    if(pWVS)
    {
      pWVS->push_back("first string");
      pWVS->push_back("second string");
    }
    return pWVS;
  }
  if(valueType == VT_double)
  {
    // simulate reading from message to populate container

    wrapper<VofD>* pWVD = dynamic_cast< wrapper<VofD>* >(pIDemo);
    if(pWVD)
    {
      pWVD->push_back(0.5);
      pWVD->push_back(-17.333);
      pWVD->push_back(0.333);
      pWVD->push_back(3.333);
    }
    return pWVD;
  }
  return 0;
}
//----< Create for each type to keep func sizes small >----

IDemo* CreateVector(VT valueType)
{
  if(valueType == VT_string)
  {
    wrapper<VofS>* pWrap = new wrapper<VofS>();
    pWrap->ContainerType() = "std::vector";
    pWrap->ValueType() = "std::string";
    IDemo* pIDemo = PopulateVector(pWrap, VT_string);
    return pIDemo;
  }
  if(valueType == VT_double)
  {
    wrapper<VofD>* pWrap = new wrapper<VofD>();
    pWrap->ContainerType() = "std::vector";
    pWrap->ValueType() = "double";
    IDemo* pIDemo = PopulateVector(pWrap, VT_double);
    return pIDemo;
  }
  return 0;
}
//----< pick an appropriate creator >----------------------

IDemo* Create(CT containerType, VT valueType)
{
  switch(containerType)
  {
  case CT_vector:
    return CreateVector(valueType);
  // other cases
  default:
    return 0;
  }
}

// end of ideas for factory
///////////////////////////////////////////////////////////

void main()
{
  std::cout << "\n  Demonstrate Ideas for Receiving in Project #3";
  std::cout << "\n ===============================================\n";

  IDemo* pIDemo = Create(CT_vector, VT_string);
  if(pIDemo)
  {
    std::cout << "\n  IDemo.size() = " << pIDemo->size();
    pIDemo->show();
  }

  pIDemo = Create(CT_vector, VT_double);
  if(pIDemo)
  {
    std::cout << "\n  IDemo.size() = " << pIDemo->size();
    pIDemo->show();
  }
}