include/util/compact.hpp

Go to the documentation of this file.

// This file is part of SPart, Spatially Located Workload Partitioner.

// Copyright (C) 2011, The Ohio State University
// SPart developed by Erdeniz O. Bas, Erik Saule and Umit V. Catalyurek 

// For questions, comments, suggestions, bugs please send e-mail to: 
// Umit V. Catalyurek   catalyurek.1@osu.edu

// SPart is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later
// version.

// SPart is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.

// You should have received a copy of the GNU General Public License
// along with SPart; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

// As a special exception, if other files instantiate templates or use
// macros or inline functions from this file, or you compile this file
// and link it with other works to produce a work based on this file,
// this file does not by itself cause the resulting work to be covered by
// the GNU General Public License. However the source code for this file
// must still be made available in accordance with section (3) of the GNU
// General Public License.

// This exception does not invalidate any other reasons why a work based
// on this file might be covered by the GNU General Public License.

// The full text of the GPL license version 2 is available in "gpl.txt".

#ifndef __UTIL__COMPACT_H
#define __UTIL__COMPACT_H

#include <assert.h>

namespace util
{
  template <typename T, bool DEBUG=false>
  class Compact2D
  {
    int sizeX, sizeY;
    T* data;
    
  private:
    Compact2D();
    Compact2D(const Compact2D&);
    const Compact2D& operator= (const Compact2D&);
    
  public:
    Compact2D(int x, int y);
    T* operator[] (int x);
    const T* operator[] (int x) const;
    ~Compact2D();
  };

  template <typename T>
  class Compact3D
  {
    int sizeX, sizeY, sizeZ;
    T* data;
    
  public:
    Compact3D(int x, int y, int z)
      :sizeX(x),sizeY(y), sizeZ(z)
    {
      assert (x>0);
      assert (y>0);
      assert (z>0);
      
      data = new T[sizeX*sizeY*sizeZ];
    }
    
    const T& operator() (int x, int y, int z) const
    {
      assert (x>=0 && x < sizeX);
      assert (y>=0 && y < sizeY);
      assert (z>=0 && z < sizeZ);
      return *(data+sizeY*sizeX*z+sizeX*y+x);
    }
    
    T& operator() (int x, int y, int z)
    {
      assert (x>=0 && x < sizeX);
      assert (y>=0 && y < sizeY);
      assert (z>=0 && z < sizeZ);
      return *(data+sizeY*sizeX*z+sizeX*y+x);
    }
    
    
    ~Compact3D()
    {
      delete[] data;
    }
  };

}

#include "compact_impl.hpp"

#endif