// MT1Q4a - Array class with policy

#include <string>
#include <iostream>

struct rowDisplayPolicy
{
  static std::string seperator() { return ", "; }
};

struct columnDisplayPolicy
{
  static std::string seperator() { return "\n  "; }
};

template <typename T, int Size, typename DisplayPolicy>
class Array {
public:
  Array(T* pT=0)
  {
    if(pT)
      for(int i=0; i<Size; ++i)
        _array[i] = *(pT + i);
  }
  // would be acceptable to make private copy declar.
  Array(const Array<T,Size,DisplayPolicy>& arr)
  {
    if(Size != arr.size()) throw ("not same size");
    for(int i=0; i<Size; ++i)
      _array[i] = arr._array[i];
  }
  int size() const { return Size; }

  // would be acceptable to make private assign declar.
  Array<T,Size,DisplayPolicy>& operator=(const Array<T,Size,DisplayPolicy>& arr)
  {
    if(Size != arr.size()) throw ("not same size");
    if(this == &arr) return *this;
    for(int i=0; i<Size; ++i)
      _array[i] = arr._array[i];
    return *this;
  }
  T& operator[](int n)
  {
    if(n<0 || Size<=n)
      throw std::exception("index out of range");
    return _array[n];
  }
  T operator[](int n) const
  {
    if(n<0 || Size<=n)
      throw std::exception("index out of range");
    return _array[n];
  }
  void display() const
  {
    std::cout << "\n  ";
    for(int i=0; i<Size-1; ++i)
      std::cout << _array[i] << DisplayPolicy::seperator();
    std::cout << _array[Size-1] << "\n";
  }
private:
  T _array[Size];
};

int main()
{
  double temp1[] = { 0, 0.5, 1.0, 1.5, 2.0 };
  Array<double, 5, rowDisplayPolicy> arr1(temp1);
  arr1.display();

  int temp2[] = { 1, 2, 3, 4, 5 };
  Array<int, 5, columnDisplayPolicy> arr2(temp2);
  arr2.display();

  std::cout << "\n  copying:";
  Array<int, 5, columnDisplayPolicy> arr3 = arr2;
  arr2.display();

  std::cout << "\n  assigning:";
  arr2 = arr3;
  arr2.display();
  std::cout << "\n";
}