VERTEX::RelationList Class Reference

#include <VtRelationList.hh>

Inheritance diagram for VERTEX::RelationList:

Public Types
typedef ConstRelationIterator	const_iterator
typedef ConstReverseRelationIterator	const_reverse_iterator
typedef RelationIterator	iterator
typedef ReverseRelationIterator	reverse_iterator

Public Member Functions
— Constructors —
	RelationList ()
virtual	~RelationList ()
— Access functions —
virtual void	clear ()
	clear all relations More...
void	push__back (Relation *rel)
	add a relation More...
Relation *	back () const
	return last relation More...
unsigned int	size () const
	return no of relations More...
virtual const iterator	erase (const iterator &pos)
	Erase an element. More...
— Iterator methods —
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
Relation *const	operator[] (unsigned int i) const
	direct access More...

— Expert functions —
Relation_v	rellist
void	print (std::ostream &os) const
void	unbook (Relation *const rel)
	get rid of relation pointer More...
virtual void	remove (Relation *const rel)
	remove a relation More...
const RelationList &	operator= (const RelationList &rhs)
bool	operator== (const RelationList &rhs) const

Detailed Description

Relation container class

Member Typedef Documentation

const_iterator

typedef ConstRelationIterator VERTEX::RelationList::const_iterator

const_reverse_iterator

typedef ConstReverseRelationIterator VERTEX::RelationList::const_reverse_iterator

iterator

typedef RelationIterator VERTEX::RelationList::iterator

reverse_iterator

typedef ReverseRelationIterator VERTEX::RelationList::reverse_iterator

Constructor & Destructor Documentation

RelationList()

VERTEX::RelationList::RelationList

(

)

{}

~RelationList()

VERTEX::RelationList::~RelationList ( )

virtual

{ clear(); }

Member Function Documentation

back()

Relation* VERTEX::RelationList::back ( ) const

inline

return last relation

{ return rellist.back(); }

begin() [1/2]

iterator VERTEX::RelationList::begin ( )

inline

{ return iterator(rellist.begin()); }

begin() [2/2]

const_iterator VERTEX::RelationList::begin ( ) const

inline

{ return const_iterator(rellist.begin()); }

clear()

void VERTEX::RelationList::clear ( void  )

virtual

clear all relations

Reimplemented in VERTEX::Vertex.

                           {
    if(rellist.empty()) return;
    
    const Relation_cit end = rellist.end();
    if(static_cast<RelationList*>(&rellist.back()->vertex) == this) {
      // Dtor called from ~Vertex
      //      cout << "delete in vertex! " << this << endl;
      for(Relation_cit it=rellist.begin(); it!=end; ++it) {
    Relation* rel = *it;
    //      cout << " Delete Relation " << rel 
    //           << " " << rel->track << endl;
    rel->track.unbook(rel);  // unbook relation
    delete rel;              // destroy relation
      }
    } else {
      // Dtor called from ~Track
      //      cout << "delete in track! " << this << endl;
      for(Relation_cit it=rellist.begin(); it!=end; ++it) {
    Relation* rel = *it;
    //      cout << " Delete Relation " << rel 
    //           << " " << rel->vertex << endl;
    rel->vertex.unbook(rel); // unbook relation
    delete rel;              // destroy relation
      }
    }
    rellist.clear();
  }

end() [1/2]

iterator VERTEX::RelationList::end ( )

inline

{ return iterator(rellist.end()); }

end() [2/2]

const_iterator VERTEX::RelationList::end ( ) const

inline

{ return const_iterator(rellist.end()); }

erase()

const iterator VERTEX::RelationList::erase ( const iterator &  pos )

virtual

Erase an element.

Reimplemented in VERTEX::Vertex.

                                                        {
    Relation* const rel = &(*pos);
    if(static_cast<RelationList*>(&rel->vertex) == this) {
      // called from Vertex
      rel->track.unbook(rel);
    } else {
      // called from Track
      rel->vertex.unbook(rel);
    }
    delete rel;
    return iterator(rellist.erase(pos.iter));
  }

operator=()

const RelationList & VERTEX::RelationList::operator=

(

const RelationList &

rhs

)

                                                                     {
    if( this == &rhs ) { return *this; }
    
    rellist = rhs.rellist;
    return *this;
  }

operator==()

bool VERTEX::RelationList::operator== ( const RelationList &  rhs ) const

inline

                                                          {
      return rellist == rhs.rellist;
    }

operator[]()

Relation *const VERTEX::RelationList::operator[]

(

unsigned int

i

)

const

direct access

                                                               {
    if(i>rellist.size()) return 0;
 
    Relation_cit it=rellist.begin();
    unsigned int j=0;
    while(j++<i) ++it;
    //    cout << "pos: " << j << endl;
    return *it;
  }

print()

void VERTEX::RelationList::print

(

std::ostream &

os

)

const

                                               {
    const Relation_cit end = rellist.end();
    for(Relation_cit it=rellist.begin(); it!=end; ++it)
      cout << **it << " ";
    return;
  }

push__back()

void VERTEX::RelationList::push__back ( Relation *  rel )

inline

add a relation

{ rellist.push_back(rel); }

rbegin() [1/2]

reverse_iterator VERTEX::RelationList::rbegin ( )

inline

{ return reverse_iterator(rellist.rbegin()); }

rbegin() [2/2]

const_reverse_iterator VERTEX::RelationList::rbegin ( ) const

inline

{ return const_reverse_iterator(rellist.rbegin()); }

remove()

void VERTEX::RelationList::remove ( Relation *const  rel )

virtual

remove a relation

Reimplemented in VERTEX::Vertex.

                                               {
    if(static_cast<RelationList*>(&rel->vertex) == this) {
      // called from Vertex
      rel->track.unbook(rel);
    } else {
      // called from Track
      rel->vertex.unbook(rel);
    }
 
    delete rel;
    rellist.remove(rel);
    return;
  }

rend() [1/2]

reverse_iterator VERTEX::RelationList::rend ( )

inline

{ return reverse_iterator(rellist.rend()); }

rend() [2/2]

const_reverse_iterator VERTEX::RelationList::rend ( ) const

inline

{ return const_reverse_iterator(rellist.rend()); }

size()

unsigned int VERTEX::RelationList::size ( ) const

inline

return no of relations

{ return rellist.size(); }

unbook()

void VERTEX::RelationList::unbook ( Relation *const  rel )

inline

get rid of relation pointer

{ rellist.remove(rel); }

Member Data Documentation

rellist

Relation_v VERTEX::RelationList::rellist

private

---

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

• src/libVt++/vt++/include/VtRelationList.hh
• src/libVt++/vt++/VtRelationList.C