STK_ITContainer2D.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as
 published by the Free Software Foundation; either version 2 of the
 License, 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 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser 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
 
 Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 */
 
/*
 * Project:  stkpp::Arrays
 * created on: 10 août 2012
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_ITCONTAINER2D_H
#define STK_ITCONTAINER2D_H
 
 
namespace STK
{
 
template <class Derived>
class ITContainer2D: public IContainer2D< hidden::Traits<Derived>::sizeRows_
                                        , hidden::Traits<Derived>::sizeCols_
                                        >
                   , public IRecursiveTemplate<Derived>
{
  public:
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
 
    typedef typename hidden::Traits<Derived>::Row Row;
    typedef typename hidden::Traits<Derived>::Col Col;
 
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
 
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
    typedef IContainer2D<sizeRows_, sizeCols_ > Base2D;
    typedef IRecursiveTemplate<Derived> Base;
 
  protected:
    ITContainer2D(): Base2D(), Base() {}
    inline ITContainer2D( RowRange const& I, ColRange const& J): Base2D(I, J), Base() {}
    inline ITContainer2D( ITContainer2D const& T): Base2D(T), Base() {}
    ~ITContainer2D() {}
 
  public:
    inline Type& elt(int i, int j)
    {
#ifdef STK_BOUNDS_CHECK
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, endCols() <= j);}
#endif
      return this->asDerived().elt2Impl(i,j);
    }
    inline TypeConst elt(int i, int j) const
    {
#ifdef STK_BOUNDS_CHECK
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer2D::elt, i, j, endCols() <= j);}
#endif
      return this->asDerived().elt2Impl(i,j);
    }
    inline Type& elt(int i) { return this->asDerived().elt1Impl(i);}
    inline TypeConst elt(int i) const { return this->asDerived().elt1Impl(i);}
    inline Type& elt() { return this->asDerived().elt0Impl();}
    inline TypeConst elt() const  { return this->asDerived().elt0Impl();}
 
    Derived& resize(int sizeRows, int sizeCols)
    { return this->asDerived().resize2Impl(sizeRows, sizeCols);}
    Derived& resize(int size) { return this->asDerived().resize1Impl(size);}
 
    void shift( int firstRow, int firstCol) { this->asDerived().shift2Impl(firstRow, firstCol);}
    void shift(int beg) { this->asDerived().shift1Impl(beg);}
};
 
} // namespace STK
 
#endif /* STK_ITCONTAINER2D_H */