#include <AbsList.h>

Inheritance diagram for AbsListNode< T >:

Public Member Functions
AbsList< T > *	get_head_node (void) const

AbsListNode< T > *	get_prev_node (void) const

AbsListNode< T > *	get_next_node (void) const

void	exclude (void)

virtual	~AbsListNode ()

	macro_copy_total (AbsListNode)

Public Attributes
T	el

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 > &)

Detailed Description

template<class T>
class AbsListNode< T >

Definition at line 72 of file AbsList.h.

Constructor & Destructor Documentation

◆ ~AbsListNode()

template<class T >

virtual AbsListNode< T >::~AbsListNode ( )

inlinevirtual

Definition at line 120 of file AbsList.h.

      {
    exclude();
    /*
      if(head_node != NULL)
    mcout<<"~AbsListNode(): error: head_node != NULL\n";
      if(prev_node != NULL)
    mcout<<"~AbsListNode(): error: prev_node != NULL\n";
      if(next_node != NULL)
    mcout<<"~AbsListNode(): error: next_node != NULL\n";
      */
  }

Member Function Documentation

◆ exclude()

template<class T >

void AbsListNode< T >::exclude ( void )

Definition at line 298 of file AbsList.h.

    {
  if (prev_node != NULL) prev_node->next_node = next_node;
  if (next_node != NULL) next_node->prev_node = prev_node;
  if (head_node != NULL)  // normally cannot be
      {
    if (head_node->qel <= 0) {
      mcerr << "ERROR in template<class T> void AbsListNode<T>::exclude()\n";
      mcerr << "head_node->qel <= 0, contradicts to request to exclude\n";
      Iprintn(mcerr, head_node->qel);
      spexit(mcerr);
    }
    if (head_node->first_node == this) head_node->first_node = next_node;
    if (head_node->last_node == this) head_node->last_node = prev_node;
    head_node->qel--;
  }
  head_node = NULL;
  prev_node = NULL;
  next_node = NULL;
}

Referenced by AbsListNode< T >::~AbsListNode().

◆ get_head_node()

template<class T >

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

inline

Definition at line 96 of file AbsList.h.

96{ return head_node; }

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

◆ get_next_node()

template<class T >

AbsListNode< T > * AbsListNode< T >::get_next_node ( void ) const

inline

Definition at line 98 of file AbsList.h.

98{ return next_node; }

Referenced by Garfield::TrackHeed::GetCluster(), BlkArr< T >::last_el(), AbsList< T >::operator=(), BlkArr< T >::operator[](), BlkArr< T >::print_struct(), BlkArr< T >::put_qel(), Garfield::TrackHeed::TransportPhoton(), and Heed::treat_particle_bank().

◆ get_prev_node()

template<class T >

AbsListNode< T > * AbsListNode< T >::get_prev_node ( void ) const

inline

Definition at line 97 of file AbsList.h.

97{ return prev_node; }

◆ macro_copy_total()

template<class T >

AbsListNode< T >::macro_copy_total ( AbsListNode< T > )

Friends And Related Function Documentation

◆ 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;
}