STK_IArray2DBase.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::Arrays
 * Purpose:  Define the Interface for the Array classes.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_IARRAY2DBASE_H
#define STK_IARRAY2DBASE_H

#include "../../Sdk/include/STK_ITContainer2D.h"

#include "STK_AllocatorBase.h"
#include "STK_Array1D.h"

namespace STK
{
template < class TYPE
         , class PTRCOL
         , class TArray2D
         >
class IArray2DBase : public ITContainer2D< TYPE, TArray2D>
                   , public AllocatorBase<PTRCOL>
{
  protected:
  Array1D<Integer> capacityCols_;

  Array1D<Range> rangeCols_;

  public:
    typedef AllocatorBase<PTRCOL> _AllocatorBaseType_;

    typedef ITContainer2D<TYPE, TArray2D> _ITContainer2DType;

  protected:
    IArray2DBase( Range const& I = Range(), Range const& J = Range())
                : _ITContainer2DType(I, J)
                , _AllocatorBaseType_()
                , capacityCols_()
                , rangeCols_()
                , capacityHo_(0)
    { mallocHo(J);}

    IArray2DBase( const IArray2DBase& T, bool ref =false)
                : _ITContainer2DType(T)
                , _AllocatorBaseType_(T, ref)
                , capacityCols_(T.capacityCols_)
                , rangeCols_(T.rangeCols_)
                , capacityHo_(T.capacityHo_)
    {
      if (!ref)
        mallocHo(T.rangeHo());
    }

    IArray2DBase( const IArray2DBase& T, Range const& I, Range const& J)
                : _ITContainer2DType(I, J)
                , _AllocatorBaseType_(T, true)
                , capacityCols_(J)
                , rangeCols_(J)
                , capacityHo_(T.capacityHo_)
    {
#ifdef STK_BOUNDS_CHECK
      if (I.first() < T.firstRow())
      { throw out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "I.first() < T.firstRow()");
      }
      if (I.last() > T.lastRow())
      { throw out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "I.last() > T.lastRow()");
      }
      if (J.first() < T.firstCol())
      { throw out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "J.first() < T.firstCol()");
      }
      if (J.last() > T.lastCol())
      { throw out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "J.last() > T.lastCol()");
      }
#endif
      // adjust capacity and range of each Cols
      for (Integer j=J.first(); j<=J.last(); j++)
      {
        // copy capacity of the column j (is it necessary ?)
        capacityCols_[j] = T.capacityCols_[j];
        // compute available range of the column j
        rangeCols_[j] = Range::inf(I, T.rangeCols_[j]);
      }
    }

    IArray2DBase( PTRCOL* q, Range const& I, Range const& J)
                : _ITContainer2DType(I, J)
                , _AllocatorBaseType_(q, J)
                , capacityCols_(J, I.size())
                , rangeCols_(J, I)
                , capacityHo_(0)
    { ;}

  public:
    virtual ~IArray2DBase()
    { ;}

    inline Integer const& capacityHo() const
    { return capacityHo_;}

    inline const Array1D<Integer> & capacityCols() const
    { return capacityCols_;}

    inline Integer const& capacityCol(Integer const& col) const
    { return capacityCols_[col];}

    inline Array1D<Range> const& rangeCols() const
    { return rangeCols_;}

    inline Range const& rangeCol(Integer const& col) const
    { return rangeCols_[col];}

    void shiftHo(Integer const& cbeg =1)
    {
      // compute increment
      Integer cinc = cbeg - this->firstCol();
      // if there is something to do
      if (cinc != 0)
      {
        // is this structure just a pointer?
        if (this->isRef())
        { throw runtime_error("IArray2DBase::shiftHo(cbeg) "
                                   "can't operate on references.");
        }
        // translate rangeHo_
        this->incRangeHo(cinc);
        // translate data
        this->shiftPtrData(cbeg);
        // tranlate capacityCols_
        capacityCols_.shift(cbeg);
        // translate rangeCols_
        rangeCols_.shift(cbeg);
      }
    }

    void swapCols(Integer const& pos1, Integer const& pos2)
    {
#ifdef STK_BOUNDS_CHECK
      if (this->firstCol() > pos1)
      { throw out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->firstCol() >pos1");
      }
      if (this->lastCol() < pos1)
      { throw out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->lastCol() <pos1");
      }
      if (this->firstCol() > pos2)
      { throw out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->firstCol() >pos2");
      }
      if (this->lastCol() < pos2)
      { throw out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->lastCol() <pos2");
      }
#endif
      // swap
      PTRCOL qaux(this->data(pos1));
      this->setData(pos1, this->data(pos2));
      this->setData(pos2, qaux);
      // update capacityCols_
      STK::swap(capacityCols_[pos1],  capacityCols_[pos2]);
      // update rangeCols_
      STK::swap(rangeCols_[pos1],  rangeCols_[pos2]);
    }

    void swap(IArray2DBase &T)
    {
      // swap AllocatorBase part
      this->AllocatorBase<PTRCOL>::swap(T);

      // swap ITContainer2D part
      this->_ITContainer2DType::swap(T);

      // swap IArray2DBase part
      STK::swap(this->capacityHo_, T.capacityHo_);
      capacityCols_.swap(T.capacityCols_);
      rangeCols_.swap(T.rangeCols_);
    }

    void pushBackByTransfer(IArray2DBase const& T)
    {
      // is this structure just a pointer?
      if (this->isRef())
      { throw runtime_error("In IArray2DBase::pushBackByTransfer(T) "
                                 "(*this) is a reference.");
      }
      // is T just a pointer?
      if (T.isRef())
      { throw runtime_error("In IArray2DBase::pushBackByTransfer(T) "
                                 "T is a reference.");
      }
      // if there is no columns, we can safely modify the vertical range
      if (this->sizeHo() <= 0)
        this->setRangeVe(T.rangeVe());
      // Are ranges corrects ?
      if (this->rangeVe() != T.rangeVe())
      { throw runtime_error("In IArray2DBase::pushBackByTransfer(T) "
                                 "this->rangeVe() != T.rangeVe().");
      }
      // break const reference
      IArray2DBase& Tref = const_cast<IArray2DBase&>(T);
      // compute horizontal range of the container after insertion
      Range rangeHo(this->rangeHo());
      // compute first index of the first column added
      const Integer first = rangeHo.last() + 1;
      // reallocate memory
      rangeHo.incLast(Tref.sizeHo());
      reallocHo(rangeHo);
      this->setRangeHo(rangeHo);
      // align T range
      const Integer last = rangeHo.last();
      Tref.shiftHo(first);
      // copy data from T
      for (Integer j=first; j<= last; j++)
      {
        copyColumn(Tref, j, j);
      }
      // release memory allocated for the columns
      Tref.freePtrData();
      Tref.setPtrData(this->ptrData(), this->rangeData());
      Tref.setRef(true);
    }

  protected:
    inline void setCapacityHo(Integer const& capacity = 0)
    { capacityHo_ = capacity;}

    void copyColumn( IArray2DBase const& T, Integer const& pos1, Integer const& pos2)
    {
      // copy column pos2 of T in pos1 of this
      this->setData(pos1, T.data(pos2));
      // set capacityCols_
      capacityCols_[pos1] = T.capacityCols_[pos2];
      // set rangeCols_
      rangeCols_[pos1] = T.rangeCols_[pos2];
    }

    void transferColumn( IArray2DBase& T, Integer const& pos1, Integer const& pos2)
    {
      // copy column pos2 of T in pos1 of this
      this->setData(pos1, T.data(pos2));
      // set capacityCols_
      capacityCols_[pos1] = T.capacityCols_[pos2];
      // set rangeCols_
      rangeCols_[pos1] = T.rangeCols_[pos2];
      // set column of T to default
      T.setDefaultCol(pos2);
    }

    void mallocHo(Range const& J)
    {
      // compute the size necessary (can be 0)
      Integer size = this->evalCapacity(J.size());
      // try to allocate memory
      try
      {
        // initialize this->capacityCols_
        capacityCols_.resize(J);
        // initialize this->rangeCols_
        rangeCols_.resize(J);
        // allocate memory for the columns
        this->mallocPtrData(size, J.first());
      }
      catch (runtime_error & error)   // if an error occur
      {
        // set default capacity (0)
        setCapacityHo();
        // set default range
        this->setRangeHo();
        // clear this->capacityCols_
        capacityCols_.clear();
        // clear this->rangeCols_
        rangeCols_.clear();
        // throw the error
        throw error;
      }
      // set new capacity if no error occur
      this->setCapacityHo(size);
    }

    void reallocHo(Range const& J)
    {
      // compute the size necessary (can be 0)
      Integer size = this->evalCapacity(J.size());
      // try to allocate memory
      try
      {
        // allocate memory for the columns
        this->reallocPtrData(size, J.first());
        // initialize this->capacityCols_
        capacityCols_.resize(J);
        // initialize this->rangeCols_
        rangeCols_.resize(J);
      }
      catch (runtime_error & error)   // if an error occur
      {
        // set default capacity (0)
        this->setCapacityHo();
        // set default range
        this->setRangeHo();
        // clear this->capacityCols_
        this->capacityCols_.clear();
        // clear this->rangeCols_
        this->rangeCols_.clear();
        // throw the error
        throw error;
      }
      // set new capacity if no error occur
      this->setCapacityHo(size);
    }

    void freeHo()
    {
      // Nothing to do for reference
      if (this->isRef()) return;
      // free memory allocated in AllocatorBase
      this->freePtrData();
      // set capacity size to default
      this->setCapacityHo();
      // set range of the Cols to default
      this->setRangeHo(Range(this->firstCol(), this->firstCol()-1));
      // set capacityCols_ to default
      capacityCols_.clear();
      // set rangeCols_ to default
      rangeCols_.clear();
    }

  private:
    Integer capacityHo_;

    inline void setDefaultCol(Integer const& pos)
    {
      // set column of T to default
      this->setData(pos, (PTRCOL)NULL);
      // set capacityCols_
      this->capacityCols_[pos] = 0;
      // set rangeCols_
      this->rangeCols_[pos] = Range();
    }
};

} // namespace STK

#endif
// STK_IARRAY2DBASE_H