Templated interface base class for two-dimensional arrays. More...

#include <STK_IArray2DBase.h>

Inheritance diagram for STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >:

Public Types
typedef IArrayBase< PTRCOL >	_IArrayBaseType
	Type for the Base reference Class.
typedef ITContainer2D< TYPE, TArrayHo, TArrayVe, TArray2D >	_ITContainer2DType
	type of the Base Container Class.
Public Member Functions
virtual	~IArray2DBase ()
	Virtual destructor.
Integer const &	capacityHo () const
	give the maximum possible number of Cols without reallocation.
const Array1D< Integer > &	capacityCols () const
	give the maximum possible number of Rows without reallocation for all Cols.
Integer const &	capacityCol (Integer const &col) const
	give the capacity of a Col.
Array1D< Range > const &	rangeCols () const
	give the range of all Cols.
Range const &	rangeCol (Integer const &col) const
	give the range of a Col.
void	shiftHo (Integer const &cbeg=1)
	New beginning index for the Cols of the object.
void	swapCols (Integer const &pos1, Integer const &pos2)
	Swapping the pos1 column and the pos2 column.
void	swap (IArray2DBase &T)
	swap this container with T.
void	pushBackByTransfer (IArray2DBase const &T)
	Append the container `T` to `this` without copying the data explicitly.
Protected Member Functions
	IArray2DBase (Range const &I=Range(), Range const &J=Range())
	Default constructor.
	IArray2DBase (const IArray2DBase &T, bool ref=false)
	Copy constructor If we want to wrap T, the main ptr will be wrapped in IArrayBase class.
	IArray2DBase (const IArray2DBase &T, Range const &I, Range const &J)
	constructor by reference, ref_=1.
	IArray2DBase (PTRCOL *q, Range const &I, Range const &J)
	Wrapper constructor We get a reference of the data.
void	copyColumn (IArray2DBase const &T, Integer const &pos1, Integer const &pos2)
	copy the column pos2 of the container T to the columnthe column of pos1 of this.
void	transferColumn (IArray2DBase &T, Integer const &pos1, Integer const &pos2)
	Transfer the column pos2 of the container T to the column pos1 of this.
void	mallocHo (Range const &J)
	Method for memory allocation and initialization of the horizontal range of the container.
void	reallocHo (Range const &J)
	Method for memory reallocation and initialization of the horizontal range of the container.
void	freeHo ()
	Horizontal Memory deallocation.
Protected Attributes
Array1D< Integer >	capacityCols_
	capacity of the columns of the container (for each column: number of available Rows without reallocation in this column)
Array1D< Range >	rangeCols_
	range of the Cols of the container.
Private Member Functions
void	setCapacityHo (Integer const &capacity=0)
	set the maximum possible number of Cols without reallocation.
void	setDefaultCol (Integer const &pos)
	set the default parameters and dimension to a column of the container.
Private Attributes
Integer	capacityHo_
	Horizontal capacity of the container (number of available Cols without reallocation)

Detailed Description

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>
class STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >

Templated interface base class for two-dimensional arrays.

A IArray2DBase is an interface class for two-dimensional containers stored in columns.

Each column has a range stored in the array rangeCols_ and a capacity stored in the array capacityCols_. It should be worth noting that we should have

   (rangeCols_[j].size() <= capacityCols_[j]) == true;
   (rangeCols_[j].isIn(this->rangeVe()) == true;
  *

Template parameter description:

TYPE is the type of the data stored in the container.
PTRCOL is the type of the ptr of column in a two-dimensional array: for exemple TYPE*, Array1D<TYPE>*, DBACCESS*....
TArrayHo is the name of the class that return a row of the array.
TArrayVe is the name of the class that return a column of the array.
TArray2D is the name of the class that implements IArray2DBase.

Definition at line 84 of file STK_IArray2DBase.h.

Member Typedef Documentation

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

typedef IArrayBase<PTRCOL> STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::_IArrayBaseType

Type for the Base reference Class.

Reimplemented in STK::MatrixUpperTriangular, STK::IArray2D< TYPE, TArray2D >, STK::IArray2D< TYPE, Container2D >, STK::IArray2D< TYPE, Array2D< TYPE > >, STK::IArray2D< Real, Array2D< Real > >, STK::IArray2D< Real, MatrixLowerTriangular >, STK::IArray2D< Real, MatrixUpperTriangular >, and STK::IArray2D< Integer, Array2D< Integer > >.

Definition at line 105 of file STK_IArray2DBase.h.

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

typedef ITContainer2D<TYPE, TArrayHo, TArrayVe, TArray2D> STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::_ITContainer2DType

type of the Base Container Class.

Definition at line 109 of file STK_IArray2DBase.h.

Constructor & Destructor Documentation

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::IArray2DBase	(	Range const &	I = `Range()`,
		Range const &	J = `Range()`
	)		`[inline, protected]`

Default constructor.

Parameters:

I	range of the Rows
J	range of the Cols

Definition at line 116 of file STK_IArray2DBase.h.

              : _ITContainer2DType(I, J)
              , _IArrayBaseType()
              , capacityHo_(0)
              , capacityCols_()
              , rangeCols_()
    { mallocHo(J);}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::IArray2DBase	(	const IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > &	T,
		bool	ref = `false`
	)		`[inline, protected]`

Copy constructor If we want to wrap T, the main ptr will be wrapped in IArrayBase class.

If we want to copy T, IArrayBase is initialized to default values.

Parameters:

T	the container to copy
ref	true if we wrap T

Definition at line 130 of file STK_IArray2DBase.h.

                : _ITContainer2DType(T)
                , _IArrayBaseType(T, ref)
                , capacityHo_(T.capacityHo_)
                , capacityCols_(T.capacityCols_)
                , rangeCols_(T.rangeCols_)
    {
      if (!ref)
        mallocHo(T.rangeHo());
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::IArray2DBase	(	const IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > &	T,
		Range const &	I,
		Range const &	J
	)		`[inline, protected]`

constructor by reference, ref_=1.

Parameters:

T	the container to copy
I	range of the Rows to wrap
J	range of the column to wrap

Definition at line 146 of file STK_IArray2DBase.h.

                : _ITContainer2DType(I, J)
                , _IArrayBaseType(T, true)
                , capacityHo_(T.capacityHo_)
                , capacityCols_(J)
                , rangeCols_(J)
    {
#ifdef STK_BOUNDS_CHECK
      if (I.first() < T.firstRow())
      { throw std::out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "I.first() < T.firstRow()");
      }
      if (I.last() > T.lastRow())
      { throw std::out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "I.last() > T.lastRow()");
      }
      if (J.first() < T.firstCol())
      { throw std::out_of_range("IArray2DBase::IArray2DBase(T, I, J) "
                           "J.first() < T.firstCol()");
      }
      if (J.last() > T.lastCol())
      { throw std::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]);
      }
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::IArray2DBase	(	PTRCOL *	q,
		Range const &	I,
		Range const &	J
	)		`[inline, protected]`

Wrapper constructor We get a reference of the data.

Parameters:

q	pointer on data
I	range of the Rows to wrap
J	range of the Cols to wrap

Definition at line 186 of file STK_IArray2DBase.h.

                : _ITContainer2DType(I, J)
                , _IArrayBaseType(q, J)
                , capacityHo_(0)
                , capacityCols_(J, I.size())
                , rangeCols_(J, I)
    { ;}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

virtual STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::~IArray2DBase ( ) [inline, virtual]

Virtual destructor.

Allocated horizontal memory is liberated by the base class IArrayBase.

Definition at line 198 of file STK_IArray2DBase.h.

    { ;}

Member Function Documentation

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Integer const& STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::capacityHo ( ) const [inline]

give the maximum possible number of Cols without reallocation.

Definition at line 204 of file STK_IArray2DBase.h.

    { return capacityHo_;}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

const Array1D<Integer>& STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::capacityCols ( ) const [inline]

give the maximum possible number of Rows without reallocation for all Cols.

Definition at line 210 of file STK_IArray2DBase.h.

    { return capacityCols_;}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Integer const& STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::capacityCol ( Integer const & col ) const [inline]

give the capacity of a Col.

Parameters:

col	index of the column we want the range

Definition at line 216 of file STK_IArray2DBase.h.

    { return capacityCols_[col];}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Array1D<Range> const& STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::rangeCols ( ) const [inline]

give the range of all Cols.

Definition at line 221 of file STK_IArray2DBase.h.

    { return rangeCols_;}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Range const& STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::rangeCol ( Integer const & col ) const [inline]

give the range of a Col.

Parameters:

col	index of the column we want the range

Definition at line 227 of file STK_IArray2DBase.h.

    { return rangeCols_[col];}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::shiftHo ( Integer const & cbeg = 1 ) [inline]

New beginning index for the Cols of the object.

Parameters:

cbeg	the index of the first column to set

Definition at line 233 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::pushBackByTransfer().

    {
      // 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 std::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);
      }
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::swapCols	(	Integer const &	pos1,
		Integer const &	pos2
	)		`[inline]`

Swapping the pos1 column and the pos2 column.

Parameters:

pos1	position of the first col
pos2	position of the second col

Definition at line 260 of file STK_IArray2DBase.h.

Referenced by STK::Svd::diag(), and STK::EigenvaluesSymmetric::diagonalize().

    {
#ifdef STK_BOUNDS_CHECK
      if (this->firstCol() > pos1)
      { throw std::out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->firstCol() >pos1");
      }
      if (this->lastCol() < pos1)
      { throw std::out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->lastCol() <pos1");
      }
      if (this->firstCol() > pos2)
      { throw std::out_of_range("IArray2D::swapCols(pos1, pos2) "
                           "this->firstCol() >pos2");
      }
      if (this->lastCol() < pos2)
      { throw std::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]);
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::swap ( IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > & T ) [inline]

swap this container with T.

Parameters:

T	the container to swap with this

Definition at line 293 of file STK_IArray2DBase.h.

Referenced by STK::Svd::diag(), STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::swap(), and STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::swapCols().

    {
      // swap IArrayBase part
      this->IArrayBase<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_);
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::pushBackByTransfer ( IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > const & T ) [inline]

Append the container T to this without copying the data explicitly.

The column of T are appended to this and T will become a reference container. Observe that the const keyword is not respected in this method: but it is useful to define this method even for constant objects. The data in itself are not altered, the Array2D become a reference on its own data.

Parameters:

T	the container to append to this

Definition at line 315 of file STK_IArray2DBase.h.

Referenced by STK::AdditiveBSplineCoefficients::run().

    {
      // is this structure just a pointer?
      if (this->isRef())
      { throw std::runtime_error("In IArray2DBase::pushBackByTransfer(T) "
                                 "(*this) is a reference.");
      }
      // is T just a pointer?
      if (T.isRef())
      { throw std::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 std::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());
      Tref.setRef(true);
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::copyColumn	(	IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > const &	T,
		Integer const &	pos1,
		Integer const &	pos2
	)		`[inline, protected]`

copy the column pos2 of the container T to the columnthe column of pos1 of this.

On of the container (either this or T but not both) have to be a reference otherwise, user will experiment a memory leak.

Parameters:

T	the container with the column to transfer
pos1	index of the column to initialize
pos2	the column in the container T to transfer in this

Definition at line 368 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::pushBackByTransfer().

    {
      // 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];
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::transferColumn	(	IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > &	T,
		Integer const &	pos1,
		Integer const &	pos2
	)		`[inline, protected]`

Transfer the column pos2 of the container T to the column pos1 of this.

Set the column pos2 in T to a default value. The column pos1 should not exists or should be deleted in this otherwise user will experiment a memory leak.

Parameters:

T	the container with the column to transfer
pos1	index of the column to initialize
pos2	the column in the container T to transfer in this

Definition at line 387 of file STK_IArray2DBase.h.

    {
      // 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);
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::mallocHo ( Range const & J ) [inline, protected]

Method for memory allocation and initialization of the horizontal range of the container.

The vertical range is not set in this method. If an error occur, we set the rangeHo_ of the container to default.

Parameters:

J	horizontal range

Definition at line 405 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::IArray2DBase().

    {
      // 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 (std::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);
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::reallocHo ( Range const & J ) [inline, protected]

Method for memory reallocation and initialization of the horizontal range of the container.

The vertical range is not set in this method. If an error occur, we set the rangeHo_ of the container to default.

Parameters:

J	horizontal range

Definition at line 442 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::pushBackByTransfer().

    {
      // 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 (std::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);
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::freeHo ( ) [inline, protected]

Horizontal Memory deallocation.

This method clear all allocated memory. The range of the columns is set to (firstCol_:firstCol_-1). The range of the Rows remain unmodified. If there is allocated memory for the columns, it should be liberated prior to this method.

Definition at line 479 of file STK_IArray2DBase.h.

    {
      // Nothing to do for reference
      if (this->isRef()) return;
      // free memory allocated in IArrayBase
      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();
    }

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::setCapacityHo ( Integer const & capacity = 0 ) [inline, private]

set the maximum possible number of Cols without reallocation.

Parameters:

capacity the maximum number of columns

Definition at line 500 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::freeHo(), STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::mallocHo(), and STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::reallocHo().

    { capacityHo_ = capacity;}

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

void STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::setDefaultCol ( Integer const & pos ) [inline, private]

set the default parameters and dimension to a column of the container.

Parameters:

pos	the position of the column to initialize to a default value.

Definition at line 508 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::transferColumn().

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

Member Data Documentation

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Integer STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::capacityHo_ [private]

Horizontal capacity of the container (number of available Cols without reallocation)

Definition at line 91 of file STK_IArray2DBase.h.

Referenced by STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::capacityHo(), STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::setCapacityHo(), and STK::IArray2DBase< TYPE, TYPE *, ArrayHo< TYPE >, Array1D< TYPE >, Container2D >::swap().

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Array1D<Integer> STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::capacityCols_ [protected]

capacity of the columns of the container (for each column: number of available Rows without reallocation in this column)

Definition at line 97 of file STK_IArray2DBase.h.

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>

Array1D<Range> STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >::rangeCols_ [protected]

range of the Cols of the container.

Definition at line 101 of file STK_IArray2DBase.h.

The documentation for this class was generated from the following file:

STK_IArray2DBase.h

STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > Class Template ReferenceSubproject STKernel::TContainer

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D> class STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D > Class Template Reference
Subproject STKernel::TContainer

template<class TYPE, class PTRCOL, class TArrayHo, class TArrayVe, class TArray2D>
class STK::IArray2DBase< TYPE, PTRCOL, TArrayHo, TArrayVe, TArray2D >