// GameBoard.cpp
  include <GameBoard.h>
  
  using namespace std;
  
  // Microsoft Visual Studio requires you to omit the following two lines.
  // However, some compilers require them.
  //const int GameBoard::kDefaultWidth;
  //const int GameBoard::kDefaultHeight;
  
  GameBoard::GameBoard(int inWidth, int inHeight) throw(bad_alloc) :
    mWidth(inWidth), mHeight(inHeight)
  {
    int i, j;
    mCells = new GamePiece* [mWidth];
  
    try {
      for (i = 0; i < mWidth; i++) {
        mCells[i] = new GamePiece[mHeight];
      }
    } catch (...) {
      //
      // Cleanup any memory we already allocated, because the destructor
      // will never get called. The upper bound of the for loop is the index
      // of the last element in the mCells array that we tried to allocate
      // (the one that failed). All indices before that one store pointers to
      // allocated memory that must be freed.
      //
      for (j = 0; j < i; j++) { 
        delete [] mCells[j];
      }
      delete [] mCells;
  
      // translate any exception to bad_alloc
      throw bad_alloc();
    }
  }
  
  GameBoard::GameBoard(const GameBoard& src) throw (bad_alloc)
  {
    copyFrom(src);
  }
  
  GameBoard::~GameBoard() throw()
  {
    // free the old memory
    for (int i = 0; i < mWidth; i++) {
      delete [] mCells[i];
    }
  
    delete [] mCells;
  }
  
  GameBoard& GameBoard::operator=(const GameBoard& rhs) throw (bad_alloc)
  {
    // check for self-assignment
    if (this == &rhs) {
      return (*this);
    }
    // free the old memory
    for (int i = 0; i < mWidth; i++) {
      delete [] mCells[i];
    }
    delete [] mCells;
  
    // copy the new memory
    copyFrom(rhs);
  
    return (*this);
  }
  
  void GameBoard::copyFrom(const GameBoard& src) throw(bad_alloc)
  {
    int i, j;
    mWidth = src.mWidth;
    mHeight = src.mHeight;
  
    mCells = new GamePiece *[mWidth];
  
    try {
      for (i = 0; i < mWidth; i++) {
        mCells[i] = new GamePiece[mHeight];
      }
    } catch (...) {
      // Cleanup any memory we already allocated.
      // If this function is called from the copy constructor,
      // the destructor will never get called.
      // Use the same upper bound on the loop as described in the constructor.
      for (j = 0; j < i; j++) {
        delete [] mCells[j];
      }
      delete [] mCells;
  
      // Set mCells and mWidth to values that will allow the
      // destructor to run without harming anything.
      // This function is called from operator=, in which case the
      // object was already constructed, so the destructor will get
      // called.
      mCells = NULL;
      mWidth = 0;
      throw bad_alloc();
    }
  
    for (i = 0; i < mWidth; i++) {
      for (j = 0; j < mHeight; j++) {
        mCells[i][j] = src.mCells[i][j];
      }
    }
  }
  
  void GameBoard::setPieceAt(int x, int y, const GamePiece& inElem)
    throw(out_of_range)
  {
    // Check for out of range arguments
    if (x < 0 || x >= mWidth || y < 0 || y >= mHeight) {
      throw out_of_range("Invalid width or height");
    }
    mCells[x][y] = inElem;
  }
  
  GamePiece& GameBoard::getPieceAt(int x, int y) throw(out_of_range)
  {
    // Check for out of range arguments
    if (x < 0 || x >= mWidth || y < 0 || y >= mHeight) {
      throw out_of_range("Invlalid width or height");
    }
    return (mCells[x][y]);
  }
  
  const GamePiece& GameBoard::getPieceAt(int x, int y) const throw(out_of_range)
  {
    // Check for out of range arguments
    if (x < 0 || x >= mWidth || y < 0 || y >= mHeight) {
      throw out_of_range("Invlalid width or height");
    }
    return (mCells[x][y]);
  }