STK_IContainer2D.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  Serge Iovleff

    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 : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  stkpp::Sdk::TContainer
 * Purpose:  Define the interface 2D Container classes.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_ICONTAINER2D_H
#define STK_ICONTAINER2D_H

#include "../../STKernel/include/STK_Range.h"

namespace STK
{
class IContainer2D
{
  protected:
    IContainer2D( Range const& I = Range(), Range const& J =  Range())
                : rangeHo_(J)
                , rangeVe_(I)
    { ;}

    IContainer2D( const IContainer2D &T)
                : rangeHo_(T.rangeHo_)
                , rangeVe_(T.rangeVe_)
    { ;}

    ~IContainer2D() { ;}

  public:
    inline Integer const& firstCol() const { return rangeHo_.first();}
    inline Integer const& lastCol() const { return rangeHo_.last();}
    inline Integer const& sizeHo() const { return rangeHo_.size();}
    inline Range const& rangeHo() const { return rangeHo_;};
    inline Integer const& firstRow() const { return rangeVe_.first();}
    inline Integer const& lastRow() const { return rangeVe_.last();}
    inline Integer const& sizeVe() const { return rangeVe_.size();}
    inline Range const& rangeVe() const { return rangeVe_;}
    inline bool empty() const { return (rangeHo_.empty() || rangeVe_.empty());}

    void resize( Range const& I, Range const& J)
    {
      // check if there is something to do
      if ((rangeVe_ == I) && (rangeHo_ == J)) return;
      //  translate beg
      shift(I.first(), J.first());
      // number of rows to del or add
      Integer rinc = I.last() - lastRow();
      // number of cols to del or add
      Integer cinc = J.last() - lastCol();
      // check if we add cols
      if (cinc >=0)   // work first on rows
      {
        if (rinc < 0) popBackRows(-rinc); // less rows
        else          pushBackRows(rinc); // more rows
        pushBackCols(cinc); // add columns
      }
      else // work first on columns
      {
        popBackCols(-cinc); // remove columns
        if (rinc < 0) popBackRows(-rinc); // less rows
        else          pushBackRows(rinc); // more rows
      }
    }

     virtual void eraseCols(Integer const& pos, Integer const& n = 1) =0;

     virtual void eraseRows(Integer const& pos, Integer const& n=1) =0;

     virtual void popBackCols( Integer const& n =1) =0;

    virtual void popBackRows( Integer const& n =1) =0;

  protected:
    Range rangeHo_;    
    Range rangeVe_;    

    inline void setRange(Range const& I = Range(), Range const& J = Range())
    {
      setRangeVe(I);
      setRangeHo(J);
    }
    inline void setRangeVe( Range const& I = Range())
    { rangeVe_ = I;}
    inline void incRangeVe( Integer const& inc)
    { rangeVe_.inc(inc);}
    inline void decRangeVe( Integer const& dec)
    { rangeVe_.dec(dec);}
    inline void setFirstVe( Integer const& beg)
    { rangeVe_.shift(beg);}
    inline void incFirstVe( Integer const& inc)
    { rangeVe_.incFirst(inc);}
    inline void decFirstVe( Integer const& dec)
    { rangeVe_.decFirst(dec);}
    inline void incLastVe( Integer const& inc)
    { rangeVe_.incLast(inc);}
    inline void decLastVe( Integer const& dec)
    { rangeVe_.decLast(dec);}
    inline void setRangeHo( Range const& J = Range())
    { rangeHo_ = J;}
    inline void incRangeHo( Integer const& inc)
    { rangeHo_.inc(inc);}
    inline void decRangeHo( Integer const& dec)
    { rangeHo_.dec(dec);}
    inline void setFirstHo( Integer const& beg)
    { rangeHo_.shift(beg);}
    inline void incFirstHo( Integer const& inc)
    { rangeHo_.incFirst(inc);}
    inline void decFirstHo( Integer const& dec)
    { rangeHo_.decFirst(dec);}
    inline void incLastHo( Integer const& inc)
    { rangeHo_.incLast(inc);}
    inline void decLastHo( Integer const& dec)
    { rangeHo_.decLast(dec);}

     inline void swap(IContainer2D& T)
     {
       // get ranges of this
       Range range_ho(rangeHo());
       Range range_ve(rangeVe());
       // set range of T to this
       setRange(T.rangeVe(), T.rangeHo());
       // set range of this to T
       T.setRange(range_ve, range_ho);
     }

  private:
    virtual void shift( Integer const& rbeg, Integer const& cbeg) =0;

    virtual void pushBackCols( Integer const& n =1) =0;

    virtual void pushBackRows( Integer const& n =1) =0;
};

} // namespace STK

#endif // STK_ICONTAINER2D_H