Structured3DVector.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program 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.

//  This program 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 this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: Structured3DVector.hpp,v 1.8 2008/03/04 20:23:33 yakoubix Exp $


#ifndef STRUCTURED_3D_VECTOR_HPP
#define STRUCTURED_3D_VECTOR_HPP

#include <Vector.hpp>
#include <Array3DShape.hpp>

template <typename T>
class Structured3DVector
  : public Vector<T>
{
private:
  T*** __structured3dView;

  Array3DShape __shape;

  void __buildView()
  {
    __structured3dView = new T**[__shape.nx()];
    for (size_t i=0; i < __shape.nx(); ++i) {
      __structured3dView[i] = new T* [__shape.ny()];
      for (size_t j=0; j < __shape.ny(); ++j) {
        __structured3dView[i][j]
          = &Vector<T>::__values[i*__shape.ny()*__shape.nz() + j*__shape.nz()];
      }
    }
  }

  void __clean()
  {
    for (size_t i=0; i<__shape.nx(); ++i)
      delete[] __structured3dView[i];
    delete [] __structured3dView;
  }
public:

  size_t nx() const
  {
    return __shape.nx();
  }

  size_t ny() const
  {
    return __shape.ny();
  }

  size_t nz() const
  {
    return __shape.nz();
  }

  const Array3DShape& shape() const
  {
    return __shape;
  }

  const T& operator()(const size_t& i, const size_t& j, const size_t& k) const
  {
    ASSERT ((i<__shape.nx()) and (j<__shape.ny()) and (k<__shape.nz()));
    return __structured3dView[i][j][k];
  }

  T& operator()(const size_t& i, const size_t& j, const size_t& k)
  {
    ASSERT ((i<__shape.nx()) and (j<__shape.ny()) and (k<__shape.nz()));
    return __structured3dView[i][j][k];
  }

  Structured3DVector<T>& operator=(const T& t)
  {
    this->Vector<T>::operator=(t);
    return *this;
  }

  Structured3DVector<T>& operator=(const Structured3DVector<T>& v)
  {
    ASSERT (__shape==v.__shape);
    this->Vector<T>::operator=(v);
    return *this;
  }

  const Structured3DVector<T>& operator=(const Vector<T>& v)
  {
    ASSERT (this->size() == v.size());
    this->Vector<T>::operator=(v);
    return *this;
  }

  void resize(const Array3DShape& shape)
  {
    this->__clean();
    __shape = shape;
    this->Vector<T>::resize(shape.size());
    this->__buildView();    
  }

  Structured3DVector(const size_t& nx, const size_t& ny, const size_t& nz)
    : Vector<T>(nx*ny*nz),
      __shape(nx,ny,nz)
  {
    this->__buildView();
  }

  Structured3DVector(const Array3DShape& shape)
    : Vector<T>(shape.size()),
      __shape(shape)
  {
    this->__buildView();
  }

  Structured3DVector(const Structured3DVector& v)
    : Vector<T>(v),
      __shape(v.__shape)
  {
    this->__buildView();
  }

  ~Structured3DVector()
  {
    this->__clean();
  }
};

#endif // STRUCTURED_3D_VECTOR_HPP

---