STK::List1D< TYPE > Class Template Reference
[Subproject STKernel::Tcontainer]

Templated One dimensionnal Horizontal List. More...

#include <STK_List1D.h>

Inherits ITContainer1D< TYPE, List1D< TYPE > >, and STK::IContainerRef.

List of all members.

Public Member Functions
	List1D (const Inx &I=Inx())
	List1D (const Inx &I, const TYPE &v)
	List1D (const List1D< TYPE > &T)
virtual	~List1D ()
TYPE &	getElt (const Integer &pos)
const TYPE &	getElt (const Integer &pos) const
List1D< TYPE >	getElt (const Inx &J) const
void	clear ()
void	shift (const Integer &beg=1)
void	pushBackElts (const Integer &n=1)
void	insertElts (Integer pos, Integer n=1)
void	popBackElts (const Integer &n=1)
void	eraseElts (Integer pos, Integer n=1)
void	swapElts (Integer j1, Integer j2)
List1D< TYPE > &	operator= (const List1D< TYPE > &T)
List1D< TYPE > &	operator= (const TYPE &v)
Protected Member Functions
	List1D (CellHo< TYPE > *const &pfirst, CellHo< TYPE > *const &plast, const Inx &J)
void	initialize (const Inx &I)
void	freeMem ()
void	setDefault ()
Protected Attributes
CellHo< TYPE > *	pfirst_
	First Element of the List.
CellHo< TYPE > *	plast_
	First Element of the List.
Private Member Functions
void	moveCurrLeft () const
void	moveCurrRight () const
void	moveCurr (Integer j) const
Private Attributes
Integer	curr_
	Current position.
CellHo< TYPE > *	pcurr_
	Current pointed position.

---

Detailed Description

template<class TYPE>
class STK::List1D< TYPE >

A List1D is an implementation of the Interface ITContainer1D.

Definition at line 72 of file STK_List1D.h.

---

Constructor & Destructor Documentation

template<class TYPE>

STK::List1D< TYPE >::List1D

(

const Inx &

I = Inx()

)

[inline]

Default Ctor : beg_ =1 and end_ =0.

Parameters:

I

range of the container

Definition at line 87 of file STK_List1D.h.

          : ITContainer1D<TYPE, List1D>(I)
          , IContainerRef(false)
    { initialize(I); }

template<class TYPE>

STK::List1D< TYPE >::List1D	(	const Inx &	I,
		const TYPE &	v
	)			[inline]

Misc Ctor with beg and end, initialization with a constant.

Parameters:

	I	range of the container
	v	initial value of the container

Definition at line 96 of file STK_List1D.h.

          : ITContainer1D<TYPE, List1D >(I)
          , IContainerRef(false)
    { initialize(I);

      CellHo<TYPE>* p1  = pfirst_;
      for ( Integer j=this->first(); j<=this->last(); j++)
      { (*p1) = v;             // overwrite the value of the current cell
        p1    = p1->getRight();   // Goto Right place
      }
    }

template<class TYPE>

STK::List1D< TYPE >::List1D

(

const List1D< TYPE > &

T

)

[inline]

Copy Ctor.

Parameters:

T

the container to copy

Definition at line 111 of file STK_List1D.h.

          : ITContainer1D<TYPE, List1D>(T)
          , IContainerRef(false)
    {
      // initialize container
      initialize(T.getRange());
      // copy the container
      CellHo<TYPE>* p1  = pfirst_;
      CellHo<TYPE>* pt1 = T.pfirst_;

      for (Integer j=T.first(); j<=T.last(); j++)
      { (*p1) = pt1->getData();   // write the value of the current cell
        p1    = p1->getRight();   // Goto Right
        pt1   = pt1->getRight();  // Goto Right
      }
    }

template<class TYPE>

STK::List1D< TYPE >::List1D	(	CellHo< TYPE > *const &	pfirst,
		CellHo< TYPE > *const &	plast,
		const Inx &	J
	)			[inline, protected]

Ctor by reference, ref_=1.

Parameters:

	pfirst	the first cell of the container to wrap
	plast	the last cell of the container to wrap
	I	range of the datas to wrap

Definition at line 134 of file STK_List1D.h.

          : ITContainer1D<TYPE, List1D>(J)
          , IContainerRef(true)
          , pfirst_(pfirst)
          , plast_(plast)
    { 
      // Current position
      curr_  = this->first();
      pcurr_ = pfirst;
    }

template<class TYPE>

virtual STK::List1D< TYPE >::~List1D

(

)

[inline, virtual]

virtual dtor.

Definition at line 151 of file STK_List1D.h.

{ if (!this->isRef()) freeMem();}

---

Member Function Documentation

template<class TYPE>

TYPE& STK::List1D< TYPE >::getElt

(

const Integer &

pos

)

[inline]

access to one element.

Parameters:

pos

index of the element

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Reimplemented in STK::DataFrame.

Definition at line 158 of file STK_List1D.h.

    {
      moveCurr(pos);
      return (pcurr_->getData());
    }

template<class TYPE>

const TYPE& STK::List1D< TYPE >::getElt

(

const Integer &

pos

)

const [inline]

access to one element const.

Parameters:

pos

index of the const element

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Reimplemented in STK::DataFrame.

Definition at line 167 of file STK_List1D.h.

    {
      moveCurr(pos);
      return (pcurr_->getData());
    }

template<class TYPE>

List1D<TYPE> STK::List1D< TYPE >::getElt

(

const Inx &

J

)

const [inline]

access to many elements.

Parameters:

J

the range of the elements

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Definition at line 176 of file STK_List1D.h.

    {
#ifdef STK_BOUNDS_CHECK
      if ((J.first()<this->first()))
      { throw std::out_of_range("List1D::getElt(J) "
                           "J.first()<this->first()");
      }
      if ((J.last()>this->last()))
      { throw std::out_of_range("List1D::getElt(J) "
                           "J.last()>this->last()");
      }
#endif
      // get J.first() cell adress
      moveCurr(J.first());
      CellHo<TYPE>* pfirst = pcurr_;
      // get J.last() cell adress
      moveCurr(J.last());
      CellHo<TYPE>* plast = pcurr_;
      // return the reference
      return List1D<TYPE>(pfirst, plast, J);
    }

template<class TYPE>

void STK::List1D< TYPE >::clear

(

)

[inline]

Clear the object. Memory is liberated and the range of the Container is set to 0:-1.

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Reimplemented in STK::DataFrame.

Definition at line 203 of file STK_List1D.h.

    {
      if (this->isRef()) return;   // Nothing to do for ref
      freeMem();        // Free mem
      this->setRange(); // Set to default the dimension
    }

template<class TYPE>

void STK::List1D< TYPE >::shift

(

const Integer &

beg = 1

)

[inline]

New first index for the object.

Parameters:

beg

new first index of the Container.

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Reimplemented in STK::DataFrame.

Definition at line 213 of file STK_List1D.h.

    {
      if (this->first() == beg) return;
#ifdef STK_DEBUG
      // is this structure just a pointer?
      if (this->isRef())
      { throw std::runtime_error("List1D::shift(pos, n) "
                            "can't operate on references.");
      }
#endif
      //compute increment
      Integer inc = beg - this->first();   
      this->incRange(inc);  // update this->range_()
      curr_ += inc;         // update current position
    }

template<class TYPE>

void STK::List1D< TYPE >::pushBackElts

(

const Integer &

n = 1

)

[inline]

Add n Elts to the container.

Parameters:

n

number of elements to add

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Definition at line 232 of file STK_List1D.h.

    {
      // if n==0 nothing to do
      if (n <= 0) return;
#ifdef STK_DEBUG
      // is this structure just a pointer?
      if (this->isRef())
      { throw std::runtime_error("List1D::pushBackElts(pos, n) "
                            "can't operate on references.");
      }
#endif
      // If the container is empty : create it
      if (this->empty())
      {
        initialize(Inx(this->first(), this->first()+ n -1));
      }
      else  // else adjust the beginning and the sizes
      {
        CellHo<TYPE> *p1, *p2;            // Auxiliary cells;
        try
        { p1 = new CellHo<TYPE>(plast_);} // Create the end+1 cell
        catch (std::bad_alloc & error)   // if an alloc error is catched
        { // throw the exception
          throw std::runtime_error("List1D::pushBackElts(n) "
                              "memory allocation failed.");
        }
        // if no error is intercepted
        plast_->setRight(p1);             // Set the right ending cell
        for (Integer j=2; j<=n; j++)    // main loop for the other cells
        { try
          { p2 = new CellHo<TYPE>(p1);}  // try to allocate memory
          catch (std::bad_alloc & error) // if an alloc error occur
          {
            while ( p1 != plast_)         // for all cells allocated
            { p2 = p1->getLeft();        // get the cell left
              delete p1;                 // delete the curent cell
              p1 = p2;                   // iterate
            }
            // set the original right side of cend 
            plast_->setRight(pfirst_);
            // and throw an exception
            throw std::runtime_error("List1D::pushBackElts(n) "
                                "memory allocation failed.");
          } // end catch
          // if no error is intercepted
          p1->setRight(p2);  // Set the right cell of the current cell
          p1 = p2;           // Set the current cell to the the next cell
        }
        p1->setRight(pfirst_);    // the last cell point on the first cell
        pfirst_->setLeft(p1);     // the first cell point on the last cell
        plast_ = p1;             // the last cell adress
        this->incLast(n); // Update size of the container
      }
    }

template<class TYPE>

void STK::List1D< TYPE >::insertElts	(	Integer	pos,
		Integer	n = 1
	)			[inline]

Insert n elts at the position pos of the container.

Parameters:

	pos	index where to insert elements
	n	number of elements to insert (default 1)

Definition at line 291 of file STK_List1D.h.

    {
      // if n<=0 nothing to do
      if (n <= 0) return;
#ifdef STK_DEBUG
      // is this structure just a pointer?
      if (this->isRef())
      { throw std::runtime_error("List1D::insertElts(pos, n) "
                            "can't operate on references.");
      }
#endif
#ifdef STK_BOUNDS_CHECK
      // check indices
      if (this->first() > pos)
      { throw std::out_of_range("List1D::insertElts(pos, n) "
                           "this->first() > pos");
      }
      if (this->last()+1 < pos)
      { throw std::out_of_range("List1D::insertElts(pos, n) "
                           "this->last()+1 < pos");
      }
#endif
      // Move the current position to j
      moveCurr(pos);
      CellHo<TYPE> *p0 = pcurr_->getLeft();// Get the j-1 cell
      CellHo<TYPE> *p1 = p0;               // Auxiliary cell;
      // main loop for the other cells
      for (Integer j1=1; j1<=n; j1++)
      { 
        CellHo<TYPE> *p2;        // Auxiliary cell;
        try
        { p2 = new CellHo<TYPE>(p1);}  // try to allocate memory
        catch (std::bad_alloc & error) // if an alloc error occur
        { while ( p1 != p0)            // for all cells allocated
          { p2 = p1;                   // get the cell left
            delete p1;                 // delete the curent cell
            p1 = p2->getLeft();        // iterate
          }
          p0->setRight(pcurr_);
          // and throw an exception
          throw std::runtime_error("List1D::insertElts(j, n) "
                              "memory allocation failed.");
        } // catch block
        // if no error is intercepted
        p1->setRight(p2);  // Set the right cell of the current cell
        p1 = p2;           // iterate
      }
      p1->setRight(pcurr_);     // the last cell point on the first cell
      pcurr_->setLeft(p1);      // the first cell point on the last cell
      this->incLast(n);   // Update the size of the container
      curr_ +=n;                // Update the current position
      if ( pos==this->first() )   // if the begininning was modified
      { pfirst_ = p0->getRight();}// set new beginning
    }

template<class TYPE>

void STK::List1D< TYPE >::popBackElts

(

const Integer &

n = 1

)

[inline]

Delete last elts of the container.

Parameters:

n

number of elts to delete

Reimplemented from STK::ITContainer1D< TYPE, List1D< TYPE > >.

Definition at line 349 of file STK_List1D.h.

    {
      // if n<=0 nothing to do
      if (n <= 0) return;
#ifdef STK_DEBUG
      // is this structure just a pointer?
      if (this->isRef())
      { throw std::runtime_error("List1D::popBackElts() "
                            "can't operate on references.");
      }
#endif
#ifdef STK_BOUNDS_CHECK
      // if there is elts to erase
      if (this->getSize()<n)
      { throw std::out_of_range("List1D::popBackElts(n) "
                           "this->getSize() < n");
      }
#endif
      // erase elts with pos = end -n +1
      eraseElts(this->last() - n +1, n);
    }

template<class TYPE>

void STK::List1D< TYPE >::eraseElts	(	Integer	pos,
		Integer	n = 1
	)			[inline]

Delete n elts at the pos index to the container.

Parameters:

	pos	index where to delete elements
	n	number of elements to delete (default 1)

Definition at line 375 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::popBackElts().

    {
      // if n==0 nothing to do
      if (n<=0) return;
#ifdef STK_DEBUG
      // is this structure just a pointer?
      if (this->isRef())
      { throw std::runtime_error("List1D::eraseElts(pos, n) "
                            "can't operate on references.");
      }
#endif
#ifdef STK_BOUNDS_CHECK
      // check bounds
      if (this->first() > pos)
      { throw std::out_of_range("List1D::eraseElts(pos, n) "
                           "this->first() > pos");
      }
      if (this->last() < pos)
      { throw std::out_of_range("List1D::eraseElts(pos, n) "
                           "this->last() < pos");
      }
      if (this->last() < pos+n-1)
      { throw std::out_of_range("List1D::eraseElts(pos, n) "
                           "this->last() < pos+n-1");
      }
#endif
      // Move the current position to j
      moveCurr(pos);
      CellHo<TYPE>* p2 = pcurr_;  // get jth cell
      moveCurrLeft();             // set current to (j-1)th pos
      // delete n cells
      for (Integer l=1; l<=n; l++)
      { CellHo<TYPE>* p3 = p2->getRight();  // get right cell in p3
        delete p2;                          // delete current cell
        p2 = p3;                            // next
      }
      // If the last col have been erased update plast_
      if (pos+n-1 == this->last()) { plast_ = pcurr_;}
      // Update the dimension of the container
      this->decLast(n);
      // If we have erased all cols
      if (this->size() == 0)
      { setDefault();}
      else
      { p2->setLeft(pcurr_);        // p2 is the j+n cell
        pcurr_->setRight(p2);       // pcurr_ is on j-1 cell
        // If the first col has been erased
        if (pos == this->first())
        { pfirst_  = p2;   // Set the new beg cell
          pcurr_ = p2;   // pcurr_
          curr_++;       // and current position
        }
      }
    }

template<class TYPE>

void STK::List1D< TYPE >::swapElts	(	Integer	j1,
		Integer	j2
	)			[inline]

Swapping the j1th col and the j2th col.

Definition at line 431 of file STK_List1D.h.

    {
#ifdef STK_BOUNDS_CHECK
      if (j1<this->first())
      { throw std::out_of_range("List1D::swapElts(j1, j2) "
                           "j1<this->first()");
      }
      if (j1>this->last())
      { throw std::out_of_range("List1D::swapElts(j1, j2) "
                           "j1>this->last()");
      }
      if (j2<this->first())
      { throw std::out_of_range("List1D::swapElts(j1, j2) "
                           "j2<this->first()");
      }
      if (j2>this->last())
      { throw std::out_of_range("List1D::swapElts(j1, j2) "
                           "j2>this->last()");
      }
#endif
      // get j1th value in aux
      moveCurr(j1);
      CellHo<TYPE> *p1 = pcurr_;
      TYPE aux = p1->getData();
      // set j2th value in j1th position
      moveCurr(j2);
      (*p1) = pcurr_->getData();
      // set j2th value to aux
      (*pcurr_) = aux;
    }

template<class TYPE>

List1D<TYPE>& STK::List1D< TYPE >::operator=

(

const List1D< TYPE > &

T

)

[inline]

operator = : overwrite the Array1D with t. We resize the object if this and T does not have the same size but if they have the same size, we don't modify the range of the object.

Parameters:

T

the container to copy

Definition at line 470 of file STK_List1D.h.

    {
      // We have to resize if this and T have not the same size
      // but if they have the same size, we don't scale the index
      if (this->size()!=T.size()) { this->resize(T.getRange());}

      /* copy without ovelapping.                                     */
      if (this->first() < T.first())
      { CellHo<TYPE> *p1 = pfirst_, *pt1 = T.pfirst_;
        for (Integer j=1; j<=this->size(); j++)
        { (*p1) = pt1->getData();   // overwrite the value
          p1    = p1->getRight();   // Goto Right for this
          pt1   = pt1->getRight();  // Goto Right for T
        }
      }
      else
      { CellHo<TYPE> *p1 = plast_, *pt1 = T.plast_;
        for (Integer j=this->size(); j>=1; j--)
        { (*p1) = pt1->getData();   // overwrite the value
          p1    = p1->getLeft();    // Goto Left for this
          pt1   = pt1->getLeft();   // Goto Left for T
        }
      }
      return *this;
    }

template<class TYPE>

List1D<TYPE>& STK::List1D< TYPE >::operator=

(

const TYPE &

v

)

[inline]

operator= : set the container to a constant value.

Parameters:

v

the value to set

Definition at line 499 of file STK_List1D.h.

    {
      CellHo<TYPE>* p1 = pfirst_;
      for (Integer j=1; j<=this->size(); j++)
      { p1->setData(v);      // overwrite the value of the current cell
        p1    = p1->getRight(); // Goto Right
      }
      return *this;
    }

template<class TYPE>

void STK::List1D< TYPE >::initialize

(

const Inx &

I

)

[inline, protected]

Protected function for initialization.

Definition at line 513 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::List1D(), and STK::List1D< IVariable * >::pushBackElts().

    {
       // set new dimensions
      this->setRange(I);
      if (this->empty())
      { 
        setDefault(); return;
      }
      // Allocate memory for the cells
      CellHo<TYPE> *p1, *p2;        // Auxiliary pointer for cells

      p1 = new CellHo<TYPE>();        // pointer on the first cell
      pfirst_ = p1;                     // set the first cell
      // main loop for the other cells
      for (Integer j=this->first()+1; j<=this->last(); j++)
      { try
        { p2 = new CellHo<TYPE>(p1);}        // try to allocate memory
        catch (std::bad_alloc & error)       // if an alloc error occur
        { while (p1 != (CellHo<TYPE>*)NULL)  // for all cells allocated
          { p2 = p1->getLeft();              // get the cell left
            delete p1;                       // delete the cell
            p1 = p2;                         // and iterate
          }
          // set default
          setDefault();
          this->setRange();
          // and throw the exception
          throw std::runtime_error("List1D::initialize(beg, end) "
                              "memory allocation failed.");
        }
        // if no error is catched
        p1->setRight(p2);      // Set the right cell
        p1 = p2;               // and iterate
      }
      plast_ = p1;              // Set the last cell
      plast_->setRight(pfirst_);  // the last cell point on the first cell
      pfirst_->setLeft(plast_);   // the first cell point on the last cell

      curr_  = this->first();    // current position is first position
      pcurr_ = pfirst_;            // Current cell is first cell
    }

template<class TYPE>

void STK::List1D< TYPE >::freeMem

(

)

[inline, protected]

Protected function for desallocation.

Reimplemented in STK::DataFrame.

Definition at line 556 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::clear(), and STK::List1D< IVariable * >::~List1D().

    {
      if (this->isRef()) return;   // Nothing to do for ref
      CellHo<TYPE> *p2, *p1 =pfirst_;   // Auxiliary pointers for cells
      // for all cells
      for (Integer j=this->first(); j<=this->last(); j++)
      { p2 = p1->getRight();               // get the right cell
        delete p1;                         // delete the curent cell
        p1 = p2;                           // and iterate
      }
      setDefault();
    }

template<class TYPE>

void STK::List1D< TYPE >::setDefault

(

)

[inline, protected]

Protected function for setting members to default.

Definition at line 571 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), STK::List1D< IVariable * >::freeMem(), and STK::List1D< IVariable * >::initialize().

    { pfirst_  = (CellHo<TYPE>*)NULL;
      plast_  = (CellHo<TYPE>*)NULL;
      pcurr_ = (CellHo<TYPE>*)NULL;
      curr_  = this->first();
    }

template<class TYPE>

void STK::List1D< TYPE >::moveCurrLeft

(

)

const [inline, private]

Private function for moving the current position : it's very low level manipulation functions, and no check is done at this level. Note that it is constant functions, as the object itself is not modified, the modified members are mutable. Move Current position to left

Definition at line 595 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), and STK::List1D< IVariable * >::moveCurr().

    {
      pcurr_ = pcurr_->getLeft();
      curr_--;
    }

template<class TYPE>

void STK::List1D< TYPE >::moveCurrRight

(

)

const [inline, private]

move Current position to right

Definition at line 602 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::moveCurr().

    {
      pcurr_ = pcurr_->getRight();
      curr_++;
    }

template<class TYPE>

void STK::List1D< TYPE >::moveCurr

(

Integer

j

)

const [inline, private]

Move current position to j

Definition at line 609 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), STK::List1D< IVariable * >::getElt(), STK::List1D< IVariable * >::insertElts(), and STK::List1D< IVariable * >::swapElts().

    { 
      // if j is greater than the current
      if (j>curr_)
      {
        if ((j-curr_) <= (this->last()-j))    // if j is near the current
          for( ;curr_!=j; ) moveCurrRight(); // move to right
        else                                 // else we are near the end
          for(curr_ = this->last(), pcurr_ = plast_ ; curr_!=j; )
            moveCurrLeft();
      }
      else  // else j is less than the current
      {
        if ((curr_-j) <= (j-this->first()))  // if j is near the current
          for( ;curr_!=j; ) moveCurrLeft();  // move to left
        else                                 // else we are near the beg
          for( curr_ = this->first(), pcurr_ = pfirst_; curr_!=j; )
            moveCurrRight();
      }
    }

---

Member Data Documentation

template<class TYPE>

CellHo<TYPE>* STK::List1D< TYPE >::pfirst_ [protected]

Definition at line 78 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), STK::List1D< IVariable * >::freeMem(), STK::List1D< IVariable * >::initialize(), STK::List1D< IVariable * >::insertElts(), STK::List1D< IVariable * >::List1D(), STK::List1D< IVariable * >::moveCurr(), STK::List1D< IVariable * >::operator=(), STK::List1D< IVariable * >::pushBackElts(), and STK::List1D< IVariable * >::setDefault().

template<class TYPE>

CellHo<TYPE>* STK::List1D< TYPE >::plast_ [protected]

Definition at line 79 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), STK::List1D< IVariable * >::initialize(), STK::List1D< IVariable * >::moveCurr(), STK::List1D< IVariable * >::operator=(), STK::List1D< IVariable * >::pushBackElts(), and STK::List1D< IVariable * >::setDefault().

template<class TYPE>

Integer STK::List1D< TYPE >::curr_ [mutable, private]

Definition at line 581 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), STK::List1D< IVariable * >::initialize(), STK::List1D< IVariable * >::insertElts(), STK::List1D< IVariable * >::List1D(), STK::List1D< IVariable * >::moveCurr(), STK::List1D< IVariable * >::moveCurrLeft(), STK::List1D< IVariable * >::moveCurrRight(), STK::List1D< IVariable * >::setDefault(), and STK::List1D< IVariable * >::shift().

template<class TYPE>

CellHo<TYPE>* STK::List1D< TYPE >::pcurr_ [mutable, private]

Definition at line 582 of file STK_List1D.h.

Referenced by STK::List1D< IVariable * >::eraseElts(), STK::List1D< IVariable * >::getElt(), STK::List1D< IVariable * >::initialize(), STK::List1D< IVariable * >::insertElts(), STK::List1D< IVariable * >::List1D(), STK::List1D< IVariable * >::moveCurr(), STK::List1D< IVariable * >::moveCurrLeft(), STK::List1D< IVariable * >::moveCurrRight(), STK::List1D< IVariable * >::setDefault(), and STK::List1D< IVariable * >::swapElts().

---

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

• STK_List1D.h