trunk/bwapi/Util/Source/Util/RectangleArray.h

Go to the documentation of this file.

#pragma once

#include <stdio.h>
#include <string.h>
#include "Exceptions.h"

namespace Util
{
  template <class Type>
  class RectangleArray
   {
     public :
       RectangleArray(unsigned int width = 1, unsigned int height = 1, Type* data = NULL);
       RectangleArray(const RectangleArray<Type>& rectangleArray);
       ~RectangleArray(void);
       unsigned int getWidth(void) const;
       unsigned int getHeight(void) const;
       Type* getItem(unsigned int x, unsigned int y);
       inline Type* operator[](int i) { return this->getColumn(i); }
       inline Type const * const operator[](int i) const {return this->getColumn(i); }
       void setItem(unsigned int x, unsigned int y, Type *item);
       void resize(unsigned int width, unsigned int height);
       void printToFile(FILE* f);
       void saveToFile(const std::string& fileName);
       void setTo(const Type& value);
       void setBorderTo(const Type& value);
     private :
       bool owner;
       unsigned int width;
       unsigned int height;
       Type *data;
       Type **columns;
       Type getData(unsigned int index);
       Type *getColumn(unsigned int index);
       const Type *getColumn(unsigned int index) const;
       void setWidth(unsigned int width);
       void setHeight(unsigned int height);       
   };
  //---------------------------------------------- CONSTRUCTOR -----------------------------------------------
  template <class Type>
  RectangleArray<Type>::RectangleArray(unsigned int width, unsigned int height, Type* data)
  {
    this->setWidth(width);
    this->setHeight(height);
    this->owner = (data == NULL);
    if (this->owner)
      this->data = new Type[this->getWidth()*this->getHeight()];
    else
      this->data = data;

    columns = new Type*[this->getWidth()];
    unsigned int i = 0;
    for (unsigned int position = 0; i < width; i++, position += height)
      columns[i] = &this->data[position];
  }
  //---------------------------------------------- CONSTRUCTOR -----------------------------------------------
  template <class Type>
  RectangleArray<Type>::RectangleArray(const RectangleArray<Type>& rectangleArray)
  :owner(true)
  {
    this->setWidth(rectangleArray.getWidth());
    this->setHeight(rectangleArray.getHeight());
    this->data = new Type[this->getWidth()*this->getHeight()];
    columns = new Type*[this->getWidth()];
    
    unsigned int i = 0;
    for (unsigned int position = 0; i < width; i++, position += height)
      columns[i] = &data[position];
    memcpy(this->data, rectangleArray.data, sizeof(Type)*this->getWidth()*this->getHeight());
  }
  //----------------------------------------------- DESTRUCTOR -----------------------------------------------
  template <class Type>
  RectangleArray<Type>::~RectangleArray(void)
  {
     delete [] columns;
     if (this->owner)
       delete [] data;
  }
  //----------------------------------------------- GET WIDTH ------------------------------------------------
  template <class Type>
  unsigned int RectangleArray<Type>::getWidth(void) const
  {
    return this->width;
  }
  //----------------------------------------------- SET WIDTH ------------------------------------------------
  template <class Type>
  void RectangleArray<Type>::setWidth(unsigned int width)
  {
    this->width = width;
  }
  //----------------------------------------------- GET HEIGHT -----------------------------------------------
  template <class Type>
  unsigned int RectangleArray<Type>::getHeight(void) const
  {
    return this->height;
  }
  //----------------------------------------------- SET HEIGHT -----------------------------------------------
  template <class Type>
  void RectangleArray<Type>::setHeight(unsigned int height)
  {
    this->height = height;
  }
  //------------------------------------------------ GET ITEM ------------------------------------------------
  template <class Type>
  Type* RectangleArray<Type>::getItem(unsigned int x, unsigned int y)
  {
    return this->getColumn(x)[y];
  }
  //------------------------------------------------ SET ITEM ------------------------------------------------
  template <class Type>
  void RectangleArray<Type>::setItem(unsigned int x, unsigned int y, Type* item)
  {
    this->getColumn(x)[y] = item;
  }
  //------------------------------------------------ GET LINE ------------------------------------------------
  template <class Type>
  Type* RectangleArray<Type>::getColumn(unsigned int index)
  {
    return columns[index];
  }
  //------------------------------------------------ GET LINE ------------------------------------------------
  template <class Type>
  const Type* RectangleArray<Type>::getColumn(unsigned int index) const
  {
    return columns[index];
  }
  //------------------------------------------------- RESIZE -------------------------------------------------
  template <class Type>
  void RectangleArray<Type>::resize(unsigned int width, unsigned int height)
  {
    if (!this->owner)
      throw GeneralException("Can't resize array that doesn't own the data");
    if (this->getWidth() == width &&
        this->getHeight() == height)
      return;

    delete [] this->columns;
    delete [] this->data;  

    this->setWidth(width);
    this->setHeight(height);

    this->data = new Type[this->width * this->height];

    this->columns = new Type*[this->width];
    unsigned int i = 0;
    for (unsigned int position = 0; i < this->width; i++, position += this->height)
      columns[i] = &data[position];
  }
  //--------------------------------------------- PRINT TO FILE ----------------------------------------------
  template <class Type>
  void RectangleArray<Type>::printToFile(FILE* f)
  {
    for (unsigned int y = 0; y < this->getHeight(); ++y)
    {
      for (unsigned int x = 0; x < this->getWidth(); ++x)
      {
        char ch = this->getColumn(x)[y];
        fprintf(f, "%c", ch);
      }
      fprintf(f, "\n");
    }
  }
  //---------------------------------------------- SAVE TO FILE ----------------------------------------------
  template <class Type>
  void RectangleArray<Type>::saveToFile(const std::string& fileName)
  {
    FILE* f = fopen(fileName.c_str(), "wt");
    if (!f)
      throw FileException("RectangleArray::saveToFile Couldn't open file " + fileName + "for writing");
    this->printToFile(f);
    fclose(f);
  }
  //------------------------------------------------- SET TO -------------------------------------------------
  template <class Type>
  void RectangleArray<Type>::setTo(const Type& value)
  {
    for (unsigned int i = 0; i < this->getWidth()*this->getHeight(); ++i)
      this->data[i] = value;
  }
  //--------------------------------------------- SET BORDER TO ----------------------------------------------
  template <class Type>
  void RectangleArray<Type>::setBorderTo(const Type& value)
  {
    for (unsigned int i = 0; i < this->width; ++i)
    {
      this->getColumn(i)[0] = value;
      this->getColumn(i)[this->height - 1] = value;
    }
    for (unsigned int i = 0; i < this->height; ++i)
    {
      this->getColumn(0)[i] = value;
      this->getColumn(this->width - 1)[i] = value;
    }    
  }
  //----------------------------------------------------------------------------------------------------------
}