ElementList Class Reference

#include <ElementList.hpp>

Collaboration diagram for ElementList:

Classes
struct	Elem

Public Member Functions
	ElementList ()
	ElementList (const ElementList &olist)
	~ElementList ()
const ElementList &	operator= (const ElementList &olist)
void	append (Element *val)
void	insert (Element *val)
void	insert_first (Element *val)
void	reset ()
void	next ()
Element *	get ()
Element *	remove ()
boolean	empty ()
int	size ()
boolean	move_to (Element *val)
int	index () const
void	index (int ind)

Private Attributes
Elem *	d_first
Elem *	d_current
int	d_size

Detailed Description

Definition at line 7 of file ElementList.hpp.

Constructor & Destructor Documentation

ElementList

(

)

Definition at line 5 of file ElementList.cpp.

                         :
  d_first(0), 
  d_current(0),
  d_size(0) {}

ElementList

(

const ElementList &

olist

)

Definition at line 10 of file ElementList.cpp.

References d_current, d_first, ElementList::Elem::d_next, and ElementList::Elem::d_val.

                                                  :
  d_size(olist.d_size) {

  // just add all the list
  Elem* oval = olist.d_first;
  Elem* prev(0);
  while( oval ){
    Elem *nelem = new ElementList::Elem( oval->d_val );
    if( prev ){
      prev->d_next = nelem;
    }
    else {
      d_first = nelem;
    }
    prev = nelem;
    oval = oval->d_next;
  }
  d_current = d_first;
}

~ElementList

(

)

Definition at line 31 of file ElementList.cpp.

References d_first.

                          {
  if( d_first ) delete d_first;
}

Member Function Documentation

void append

(

Element *

val

)

Definition at line 58 of file ElementList.cpp.

References d_current, d_first, ElementList::Elem::d_next, and d_size.

Referenced by Mesh::replaceNode().

                                    {

  Elem* bef(0);
  Elem* af( d_first );
  while( af ){
    bef = af;
    af = af->d_next;
  }
  if( bef ){
    bef->d_next = new ElementList::Elem( val );
  }
  else {
    d_first = new Elem( val );
    d_current = d_first;
  }
  d_size++;
}

Here is the caller graph for this function:

boolean empty ( void  )

inline

Definition at line 91 of file ElementList.hpp.

References d_size, FALSE, and TRUE.

                                 {
  return ( d_size <= 0 ? TRUE : FALSE);
}

Element * get ( )

inline

Definition at line 87 of file ElementList.hpp.

References d_current, and ElementList::Elem::d_val.

Referenced by Node::getSeparateElements(), and Mesh::replaceNode().

                                 {
  return d_current->d_val;
}

Here is the caller graph for this function:

int index

(

)

const

Definition at line 110 of file ElementList.cpp.

References d_current, d_first, and ElementList::Elem::d_next.

Referenced by read_msh(), Mesh::replaceNode(), rflu_readpostinfo(), write_grda(), write_grdb(), and write_msh().

                              {

  int ind = 0;
  Elem* pass = d_first;
  while( pass != d_current ){
    ind++;
    pass = pass->d_next;
  }
  return ind;
}

Here is the caller graph for this function:

void index

(

int

ind

)

Definition at line 121 of file ElementList.cpp.

References d_current, d_first, ElementList::Elem::d_next, and i.

                                {

  d_current = d_first;
  int i;
  for( i = 0; i < ind; i++ ){
    d_current = d_current->d_next;
  }
}

void insert ( Element *  val )

inline

Definition at line 55 of file ElementList.hpp.

References d_current, d_first, ElementList::Elem::d_next, and d_size.

                                            { // at d_current
  if( !d_current && d_first){
    cerr << " Gevalt - insert\n";
    return;
  }
  d_size++;
  if( !d_current ){
    d_first = new ElementList::Elem( val );
    d_current = d_first;
    return;
  }
  d_current->d_next = new Elem( val, d_current->d_next);
}

void insert_first ( Element *  val )

inline

Definition at line 69 of file ElementList.hpp.

References d_current, d_first, and d_size.

Referenced by Node::getSeparateElements().

                                                  { // at d_current
  d_size++;
  d_first = new ElementList::Elem( val, d_first);
  d_current = d_first;
}

Here is the caller graph for this function:

boolean move_to

(

Element *

val

)

Definition at line 102 of file ElementList.cpp.

References d_current, d_first, ElementList::Elem::d_next, ElementList::Elem::d_val, FALSE, and TRUE.

Referenced by Node::getSeparateElements(), and Mesh::replaceNode().

                                        {
  d_current = d_first;
  while( d_current && d_current->d_val != val ){
    d_current = d_current->d_next;
  }
  return( d_current ? TRUE : FALSE );
}

Here is the caller graph for this function:

void next ( )

inline

Definition at line 80 of file ElementList.hpp.

References d_current, d_first, and ElementList::Elem::d_next.

Referenced by Node::getSeparateElements(), and Mesh::replaceNode().

                              {
  d_current = d_current->d_next;
  if( !d_current ){
    d_current = d_first;
  }
}

Here is the caller graph for this function:

const ElementList & operator=

(

const ElementList &

olist

)

Definition at line 35 of file ElementList.cpp.

References d_current, d_first, ElementList::Elem::d_next, d_size, and ElementList::Elem::d_val.

                                                                  {

  if( d_first ) delete d_first;

  d_size = olist.d_size;
  // just add all the list
  Elem* oval = olist.d_first;
  Elem* prev(0);
  while( oval ){
    Elem *nelem = new ElementList::Elem( oval->d_val );
    if( prev ){
      prev->d_next = nelem;
    }
    else {
      d_first = nelem;
    }
    prev = nelem;
    oval = oval->d_next;
  }
  d_current = d_first;
  return *this;
}

Element * remove

(

)

Definition at line 76 of file ElementList.cpp.

References d_current, d_first, ElementList::Elem::d_next, d_size, and ElementList::Elem::d_val.

                            {
  Element* val = d_current->d_val;
  
  d_size--;

  Elem* bef(0);
  Elem* af( d_first );
  while( af != d_current){  
    bef = af;
    af = af->d_next;
  }
  if( !bef ){
    d_first = d_current->d_next;
  }
  else {
    bef->d_next = d_current->d_next;
  }
  d_current = d_current->d_next;
  af->d_next = 0;
  delete af;// the old current - remove only it
  if( !d_current ) d_current = d_first;
  return val;
}

void reset ( )

inline

Definition at line 76 of file ElementList.hpp.

References d_current, and d_first.

Referenced by Node::getSeparateElements(), and Mesh::replaceNode().

                               {
  d_current = d_first;
}

Here is the caller graph for this function:

int size ( )

inline

Definition at line 95 of file ElementList.hpp.

References d_size.

Referenced by Node::getSeparateElements(), and Mesh::replaceNode().

                            {
  return d_size;
}

Here is the caller graph for this function:

Member Data Documentation

Elem* d_current

private

Definition at line 49 of file ElementList.hpp.

Referenced by append(), ElementList(), get(), index(), insert(), insert_first(), move_to(), next(), operator=(), remove(), and reset().

Elem* d_first

private

Definition at line 48 of file ElementList.hpp.

Referenced by append(), ElementList(), index(), insert(), insert_first(), move_to(), next(), operator=(), remove(), reset(), and ~ElementList().

int d_size

private

Definition at line 51 of file ElementList.hpp.

Referenced by append(), empty(), insert(), insert_first(), operator=(), remove(), and size().

---

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

• ElementList.hpp
• ElementList.cpp