AbsList< T > Class Template Reference

#include <AbsList.h>

Inheritance diagram for AbsList< T >:

Public Member Functions
	AbsList (void)
	AbsList (const T &fel)
AbsListNode< T > *	get_first_node (void) const
AbsListNode< T > *	get_last_node (void) const
AbsListNode< T > *	get_next_node (AbsListNode< T > *an) const
AbsListNode< T > *	get_prev_node (AbsListNode< T > *an) const
AbsListNode< T > *	insert_before (AbsListNode< T > *, const T &fel)
AbsListNode< T > *	insert_after (AbsListNode< T > *an, const T &fel)
AbsListNode< T > *	push_front (const T &fel)
AbsListNode< T > *	prepend (const T &fel)
AbsListNode< T > *	push_back (const T &fel)
AbsListNode< T > *	append (const T &fel)
void	erase (AbsListNode< T > *an)
void	remove (AbsListNode< T > *an)
void	remove (const T &t)
void	remove_all (const T &t)
void	clear (void)
long	get_qel (void) const
	AbsList (const AbsList< T > &al)
	AbsList (PILF_CONST AbsList< T > &al, Pilfer)
void	pilfer (PILF_CONST AbsList< T > &al)
AbsList< T > &	operator= (const AbsList< T > &al)
virtual	~AbsList ()
	macro_copy_total (AbsList)

Friends
AbsListNode< T > *	glob_insert_before (AbsList< T > &, AbsListNode< T > *, const T &fel)
AbsListNode< T > *	glob_insert_after (AbsList< T > &, AbsListNode< T > *, const T &fel)
void	glob_pilfer (AbsList< T > &, PILF_CONST AbsList< T > &)
void	AbsListNode (void)

Detailed Description

template<class T>
class AbsList< T >

Definition at line 156 of file AbsList.h.

Constructor & Destructor Documentation

AbsList() [1/4]

template<class T >

AbsList< T >::AbsList ( void  )

inline

Definition at line 165 of file AbsList.h.

: first_node(NULL), last_node(NULL), qel(0) { ; }

AbsList() [2/4]

template<class T >

AbsList< T >::AbsList ( const T &  fel )

inline

Definition at line 165 of file AbsList.h.

                           : first_node(NULL), last_node(NULL), qel(0) {
    insert_after(NULL, fel);
  }

AbsList() [3/4]

template<class T >

AbsList< T >::AbsList ( const AbsList< T > &  al )

inline

Definition at line 236 of file AbsList.h.

      :
#ifndef DONT_USE_ABSPTR
        RegPassivePtr(),
#endif
        first_node(NULL),
        last_node(NULL),
        qel(0) {
#ifdef DEBUG_ABSLIST
    mcout << "AbsList<T>(const AbsList<T>& al) is working\n";
#endif
    *this = al;
  }

AbsList() [4/4]

template<class T >

AbsList< T >::AbsList ( PILF_CONST AbsList< T > &  al, Pilfer    )

inline

Definition at line 249 of file AbsList.h.

      : first_node(NULL), last_node(NULL), qel(0) {
#ifdef DEBUG_ABSLIST
    mcout << "AbsList<T>(PILF_MUTABLE AbsList<T>& al, Pilfer) is working\n";
#endif
    pilfer(al);
  }

~AbsList()

template<class T >

virtual AbsList< T >::~AbsList ( )

inlinevirtual

Definition at line 258 of file AbsList.h.

{ clear(); }

Member Function Documentation

append()

template<class T >

AbsListNode< T > * AbsList< T >::append ( const T &  fel )

inline

Definition at line 216 of file AbsList.h.

{ return push_back(fel); }

Referenced by FunNameStack::FunNameStack().

clear()

template<class T >

void AbsList< T >::clear ( void  )

inline

Definition at line 227 of file AbsList.h.

                          {
    while (first_node != NULL) {  //mcout<<"erasing first node\n";
      erase(first_node);
    }
    ;
  }

Referenced by BlkArr< T >::allocate_block(), BlkArr< T >::clear(), BlkArr< T >::pilfer(), and AbsList< T >::~AbsList().

erase()

template<class T >

void AbsList< T >::erase

(

AbsListNode< T > *

an

)

Definition at line 547 of file AbsList.h.

                                                             {
  if (aln->get_head_node() != this) {
    mcerr << "ERROR in template<class T> void AbsList<T>::erase(...)\n";
    mcerr << "aln->get_heed_node() != this\n";
    spexit(mcerr);
  }
  if (qel <= 0)  // empty list - it is not consistent
      {
    mcerr << "ERROR in template<class T> void AbsList<T>::erase(...)\n";
    mcerr << "qel <= 0 before erase \n";
    Iprintn(mcerr, qel);
    spexit(mcerr);
  }
 
  //AbsListNode<T>* aaln = aln.get();
  //aln->exclude();  now called from delete
  /*
  if(first_node == aln)
  {
    first_node = aln->get_next_node();
  }
  if(last_node == aln)
  {
    last_node = aln->get_prev_node();
  }
  */
  delete aln;
  //qel--; now in exclude();
  //aaln->get_prev_node()->put_next_node(aaln->get_next_node() );
  //aaln->get_next_node()->put_prev_node(aaln->get_prev_node() );
}

Referenced by AbsList< T >::clear(), BlkArr< T >::put_qel(), and AbsList< T >::remove().

get_first_node()

template<class T >

AbsListNode< T > * AbsList< T >::get_first_node ( void  ) const

inline

Definition at line 173 of file AbsList.h.

{ return first_node; }

Referenced by BlkArr< T >::BlkArr(), BlkArr< T >::last_el(), AbsList< T >::operator=(), BlkArr< T >::operator[](), BlkArr< T >::print_struct(), and BlkArr< T >::put_qel().

get_last_node()

template<class T >

AbsListNode< T > * AbsList< T >::get_last_node ( void  ) const

inline

Definition at line 174 of file AbsList.h.

{ return last_node; }

Referenced by BlkArr< T >::put_qel().

get_next_node()

template<class T >

AbsListNode< T > * AbsList< T >::get_next_node ( AbsListNode< T > *  an ) const

inline

Definition at line 175 of file AbsList.h.

                                                                 {
    if (an == NULL)
      return first_node;
    else
      return an->get_next_node();
  }

Referenced by Heed::AtomDef::get_A(), Heed::AtomDef::get_AtomDef(), Heed::MatterDef::get_MatterDef(), Heed::MoleculeDef::get_MoleculeDef(), Heed::particle_def::get_particle_def(), operator<<(), Heed::particle_type::particle_type(), print_AbsList(), Heed::AtomDef::printall(), Heed::MatterDef::printall(), Heed::MoleculeDef::printall(), Heed::particle_def::printall(), Heed::AtomDef::verify(), and Heed::MatterDef::verify().

get_prev_node()

template<class T >

AbsListNode< T > * AbsList< T >::get_prev_node ( AbsListNode< T > *  an ) const

inline

Definition at line 181 of file AbsList.h.

                                                                 {
    if (an == NULL)
      return last_node;
    else
      return an->get_prev_node();
  }

get_qel()

template<class T >

long AbsList< T >::get_qel ( void  ) const

inline

Definition at line 235 of file AbsList.h.

{ return qel; }

Referenced by operator<<(), and print_AbsList().

insert_after()

template<class T >

AbsListNode< T > * AbsList< T >::insert_after ( AbsListNode< T > *  an, const T &  fel  )

inline

Definition at line 487 of file AbsList.h.

                                                                          {
  return glob_insert_after(*this, aln, fel);
}

Referenced by AbsList< T >::push_back(), and BlkArr< T >::put_qel().

insert_before()

template<class T >

AbsListNode< T > * AbsList< T >::insert_before ( AbsListNode< T > *  aln, const T &  fel  )

inline

Definition at line 374 of file AbsList.h.

                                                                           {
  return glob_insert_before<T>(*this, aln, fel);
}

Referenced by AbsList< T >::push_front().

macro_copy_total()

template<class T >

AbsList< T >::macro_copy_total

(

AbsList< T >

)

operator=()

template<class T >

AbsList< T > & AbsList< T >::operator=

(

const AbsList< T > &

al

)

Definition at line 618 of file AbsList.h.

                                                                        {
#ifdef DEBUG_ABSLIST
  mcout
      << "AbsList<T>& AbsList<T>::operator=(const AbsList<T>& f) is starting\n";
#endif
  clear();
  AbsListNode<T>* aln = get_last_node();
  AbsListNode<T>* faln = f.get_first_node();
  while (faln != NULL) {
    insert_after(aln, faln->el);
    aln = get_last_node();
    faln = faln->get_next_node();
  }
  return *this;
}

pilfer()

template<class T >

void AbsList< T >::pilfer

(

PILF_CONST AbsList< T > &

al

)

Definition at line 664 of file AbsList.h.

                                                                    {
  glob_pilfer(*this, al);
}

Referenced by AbsList< T >::AbsList(), and BlkArr< T >::pilfer().

prepend()

template<class T >

AbsListNode< T > * AbsList< T >::prepend ( const T &  fel )

inline

Definition at line 212 of file AbsList.h.

{ return push_front(fel); }

push_back()

template<class T >

AbsListNode< T > * AbsList< T >::push_back ( const T &  fel )

inline

Definition at line 213 of file AbsList.h.

                                          {
    return insert_after(last_node, fel);
  }

Referenced by AbsList< T >::append().

push_front()

template<class T >

AbsListNode< T > * AbsList< T >::push_front ( const T &  fel )

inline

Definition at line 209 of file AbsList.h.

                                           {
    return insert_before(first_node, fel);
  }

Referenced by AbsList< T >::prepend().

remove() [1/2]

template<class T >

void AbsList< T >::remove ( AbsListNode< T > *  an )

inline

Definition at line 219 of file AbsList.h.

                                         {
    erase(an);
  }                             // function to exclude the node

remove() [2/2]

template<class T >

void AbsList< T >::remove

(

const T &

t

)

Definition at line 580 of file AbsList.h.

    {
  AbsListNode<T>* an = NULL;
  while ((an = get_next_node(an)) != NULL) {
    if (an->el == t) {
      remove(an);
      break;
    }
  }
}

remove_all()

template<class T >

void AbsList< T >::remove_all

(

const T &

t

)

Definition at line 593 of file AbsList.h.

    {
  AbsListNode<T>* an = NULL;
  while ((an = get_next_node(an)) != NULL) {
    if (an->el == t) {
      remove(an);
    }
  }
}

Friends And Related Function Documentation

AbsListNode

template<class T >

void AbsListNode ( void  )

friend

glob_insert_after

template<class T >

AbsListNode< T > * glob_insert_after ( AbsList< T > &  al, AbsListNode< T > *  aln, const T &  fel  )

friend

Definition at line 441 of file AbsList.h.

                                                {
  AbsListNode<T>* new_aln = NULL;
  if (aln == NULL)  // no node after which it needs to insert
      {
    if (al.qel == 0)  // empty list, OK
        {
      al.first_node = new AbsListNode<T>(&al, NULL, NULL, fel);
      al.last_node = al.first_node;
      new_aln = al.first_node;
      al.qel = 1;
    } else {
      mcerr << "ERROR in template<class T> AbsListNode<T>* glob_insert_after\n";
      mcerr << " aln is zero, but the list is not empty\n";
      spexit(mcerr);
    }
  } else {
    if (aln->get_head_node() != &al)  // not our node or list
        {
      mcerr
          << "ERROR in template<class T> AbsListNode<T>*  glob_insert_after\n";
      mcerr << "aln->get_heed_node() != this\n";
      Iprint2n(mcerr, aln->get_head_node(), &al);
      spexit(mcerr);
    } else {
      if (al.qel <= 0)  // all ours but empty list - it is not consistent
          {
        mcerr << "ERROR in template<class T> AbsListNode<T>*  "
                 "glob_insert_after\n";
        mcerr << "qel <= 0 but aln is not empty\n";
        Iprintn(mcerr, al.qel);
        spexit(mcerr);
      } else {
        new_aln = new AbsListNode<T>(&al, aln, aln->get_next_node(), fel);
        //if(new_aln->get_next_node().get() == NULL)
        if (aln == al.last_node) {
          al.last_node = new_aln;
        }
        al.qel++;
      }
    }
  }
  return new_aln;
}

glob_insert_before

template<class T >

AbsListNode< T > * glob_insert_before ( AbsList< T > &  al, AbsListNode< T > *  aln, const T &  fel  )

friend

Definition at line 322 of file AbsList.h.

                                                 {
  AbsListNode<T>* new_aln = NULL;
  if (aln == NULL)  // means to insert at the first place
      {
    if (al.qel == 0)  // no elements, then the addresses should be empty as well
        {
      if (al.first_node != NULL || al.last_node != NULL) {
        mcerr << "ERROR in template<class T> AbsListNode<T>*  "
                 "glob_insert_before\n";
        mcerr << "qel == 0, but first_node != NULL || last_node != NULL \n";
        Iprintn(mcerr, al.first_node);
        Iprintn(mcerr, al.last_node);
        spexit(mcerr);
      }
      al.first_node = new AbsListNode<T>(&al, NULL, NULL, fel);
      al.last_node = al.first_node;
      new_aln = al.first_node;
      al.qel = 1;
    } else {
      mcerr
          << "ERROR in template<class T> AbsListNode<T>*  glob_insert_before\n";
      mcerr << " aln is zero, but the list is not empty\n";
      spexit(mcerr);
    }
  } else {
    if (aln->get_head_node() != &al) {
      mcerr
          << "ERROR in template<class T> AbsListNode<T>*  glob_insert_before\n";
      mcerr << "aln->get_head_node() != this\n";
      Iprint2n(mcerr, aln->get_head_node(), al);
      spexit(mcerr);
    } else {
      if (al.qel <= 0) {
        mcerr << "ERROR in template<class T> AbsListNode<T>*  "
                 "glob_insert_before\n";
        mcerr << "qel <= 0 but aln is not empty\n";
        Iprintn(mcerr, al.qel);
        spexit(mcerr);
      } else {
        new_aln = new AbsListNode<T>(&al, aln->get_prev_node(), aln, fel);
        if (aln == al.first_node) {
          al.first_node = new_aln;
        }
        al.qel++;
      }
    }
  }
  return new_aln;
}

glob_pilfer

template<class T >

void glob_pilfer ( AbsList< T > &  this_al, PILF_CONST AbsList< T > &  al  )

friend

Definition at line 635 of file AbsList.h.

                                                                 {
#ifdef DEBUG_ABSLIST
  mcout << "void glob_pilfer(AbsList<T>& this_al, PILF_CONST AbsList<T>& al) "
           "is starting\n";
#endif
  if (this_al.qel != 0) {
    if (al.qel != 0) {
      mcerr << "ERROR in glob_pilfer(...):\n";
      mcerr << "Both the destination and source lists are not empty\n";
      // For explanations why it is dangerous, see similar function
      // of ActivePtr.
      spexit(mcerr);
    } else {
      this_al.clear();
    }
  }
  this_al.first_node = al.first_node;
  this_al.last_node = al.last_node;
  this_al.qel = al.qel;
  AbsListNode<T>* cur_node = this_al.first_node;
  while (cur_node != NULL) {
    cur_node->head_node = &this_al;
    cur_node = cur_node->get_next_node();
  }
  al.first_node = NULL;
  al.last_node = NULL;
  al.qel = 0;
}

---

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

• AbsList.h