STK_ITContainer1D.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 1D templated Container class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_ITCONTAINER1D_H
#define STK_ITCONTAINER1D_H

#include "STK_IContainerBase.h"
#include "STK_IContainer1D.h"
#include "../../STKernel/include/STK_Exceptions.h"

namespace STK
{
template <class TYPE, class TContainer1D>
class ITContainer1D : public IContainerBase<TContainer1D>
                    , virtual public IContainer1D
{
  protected:
    ITContainer1D( Range const& I = Range())
                 : IContainerBase<TContainer1D>(IContainerBase<TContainer1D>::_1D_)
                 , range_(I)
    { this->ranges_.push_back(&range_);}

    ITContainer1D( const ITContainer1D& T)
                 : IContainerBase<TContainer1D>(IContainerBase<TContainer1D>::_1D_)
                 , range_(T.range_)
    { this->ranges_.push_back(&range_);}

  public:
    typedef TYPE Type;
    virtual ~ITContainer1D() { ;}

    inline Integer const& first() const { return range_.first();}

    inline Integer const& last() const { return range_.last();}

    inline Integer const& size() const { return range_.size();}

    inline Range const& range() const { return range_;}

    inline TYPE& elt(Integer const& pos)
    { return this->asLeaf().elt(pos);}

    inline TYPE const& elt(Integer const& pos) const
    { return this->asLeaf().elt(pos);}

    inline TContainer1D elt(Range const& I) const
    { return this->asLeaf().elt(I);}

    inline TYPE& operator[](Integer const& pos)
    { return this->asLeaf().elt(pos);}

    inline TYPE const& operator[](Integer const& pos) const
    { return this->asLeaf().elt(pos);}

    inline TContainer1D operator[](Range const& I) const
    { return this->asLeaf().elt(I);}

    void swap(Integer const& pos1, Integer const& pos2)
    {
#ifdef STK_BOUNDS_CHECK
      // check indices
      if (pos1<this->first())
      { throw out_of_range("ITContainer1D::swap(pos1, pos2) "
                                "pos1<this->first()");
      }
      if (pos1>this->last())
      { throw out_of_range("ITContainer1D::swap(pos1, pos2) "
                                "pos1>this->last()");
      }
      if (pos2<this->first())
      { throw out_of_range("ITContainer1D::swap(pos1, pos2) "
                                "pos2<this->first()");
      }
      if (pos2>this->last())
      { throw out_of_range("ITContainer1D::swap(pos1, pos2) "
                                "pos2>this->last()");
      }
#endif
      // swap
      TYPE aux(this->asLeaf().elt(pos1));
      this->asLeaf().elt(pos1) = this->asLeaf().elt(pos2);
      this->asLeaf().elt(pos2) = aux;
    }

    inline TYPE& at(Integer const& pos)
    {
      if ((pos<this->first()))
      {
        throw out_of_range("ITContainer1D::at(pos) "
                                "pos<this->first()");
      }
      if ((pos>this->last()))
      { throw out_of_range("ITContainer1D::at(pos) "
                                "pos>this->last()");
      }
      return this->asLeaf().elt(pos);
    }

    inline TYPE const& at(Integer const& pos) const
    {
      if (pos<this->first())
      {
        throw out_of_range("ITContainer1D::at(pos) "
                                "pos<this->first()");
      }
      if (pos>this->last())
      { throw out_of_range("ITContainer1D::at(pos) "
                                "pos>this->last()");
      }
      return this->asLeaf().elt(pos);
    }

    inline TYPE& front()
    { return this->asLeaf().elt(this->first()); }

    inline TYPE const& front() const
    { return this->asLeaf().elt(this->first()); }

    inline TYPE& back()
    { return this->asLeaf().elt(this->last()); }

    inline TYPE const& back() const
    { return this->asLeaf().elt(this->last()); }

    inline void push_back(TYPE const& v)
    {
      this->asLeaf().pushBack();
      this->asLeaf().elt(this->last()) = v;
    }

//    inline void push_front(TYPE const& v)
//    { insert(Range(this->first(), this->first()), v);}

//    inline void insert(Range const& I, TYPE const& v)
//    {
//      this->insertElt(I.first(), I.size());
//      for (Integer i=I.first(); i<=I.last(); i++)
//        this->asLeaf().elt(i) = v;
//    }

  protected:
    Range range_;

    inline void setRange(Range const& I = Range())
    { range_ = I;}

    inline void incRange(Integer const& inc =1)
    { range_.inc(inc);}

    inline void incFirst(Integer const& inc = 1)
    { range_.incFirst(inc);}

    inline void decFirst(Integer const& inc = 1)
    { range_.decFirst(inc);}

    inline void incLast(Integer const& inc =1)
    { range_.incLast(inc);}

    inline void decLast(Integer const& inc =1)
    { range_.decLast(inc);}
};

} // namespace STK

#endif
// STK_ITCONTAINER1D_H