| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 2010

# RefTableBase< FROM, MAPENTRY > Class Template Reference

template <class FROM, class TO, class MAPENTRY> class RefTable More...

`#include <RefTable.h>`

Inheritance diagram for RefTableBase< FROM, MAPENTRY >:

[legend]
Collaboration diagram for RefTableBase< FROM, MAPENTRY >:

[legend]

List of all members.

## Public Types
typedef FROM | KeyType
typedef MAPENTRY | EntryType
typedef RefTableBase< FROM, EntryType > | BaseType
typedef GaudiUtils::HashMap < const void *, EntryType > | TableType
| Define Reference map.
typedef TableType::iterator | iterator
| Definition of map iterator.
typedef TableType::const_iterator | const_iterator
| Definition of map iterator (CONST).
## Public Member Functions
| RefTableBase (const CLID &clid, int len)
| Constructors.
virtual | ~RefTableBase ()
| Destructor.
virtual void | clear ()
| Clear Reference map.
iterator | begin ()
| Start of direct access iterator.
const_iterator | begin () const
| Start of direct access iterator (CONST).
iterator | end ()
| End of direct access iterator.
const_iterator | end () const
| End of direct access iterator (CONST).
long | size () const
| Size of References.
void | reserve (int len)
| Size of References.
virtual StreamBuffer & | serialize (StreamBuffer &s) const
| Serialize the object for writing.
virtual StreamBuffer & | serialize (StreamBuffer &s)
| Serialize the object for reading.
## Public Attributes
CLID | m_clid
| Class id of the reference table.
## Protected Member Functions
bool | insertMapElement (const KeyType *from, EntryType &to)
| Insert new Entry into Reference container.
EntryType * | i_reference (const KeyType *from)
| Find Reference from it's source entry.
const EntryType * | i_reference (const KeyType *from) const
| Find Reference from it's source entry (CONST).
## Private Attributes
TableType | m_table
| Reference map.
SmartRef< KeyType > | m_fromRef
| This is a completely useless entry, but the compiler wants it to be instantiated before the serialize function is defined.

## Detailed Description

### template<class FROM, class MAPENTRY>
class RefTableBase< FROM, MAPENTRY >

template <class FROM, class TO, class MAPENTRY> class RefTable

ClassName: RefTableBase

Description: Essential information of the RefTable References can be of several kinds: multiplicity: FROM TO 1 0 = 1 (no existing Reference) 1 1 <-> 1 relationship n 1 <-> n relationship Template parameters: FROM type of the source object TO type of the referenced object(s) MAPENTRY entry type used for the referenced objects within the map.

Author: Markus Frank

Definition at line 46 of file RefTable.h.

## Member Typedef Documentation

template<class FROM, class MAPENTRY>

typedef FROM RefTableBase< FROM, MAPENTRY >::KeyType

Definition at line 49 of file RefTable.h.

template<class FROM, class MAPENTRY>

typedef MAPENTRY RefTableBase< FROM, MAPENTRY >::EntryType

Definition at line 51 of file RefTable.h.

template<class FROM, class MAPENTRY>

typedef RefTableBase<FROM, EntryType> RefTableBase< FROM, MAPENTRY >::BaseType

Definition at line 53 of file RefTable.h.

template<class FROM, class MAPENTRY>

typedef GaudiUtils::HashMap< const void* , EntryType > RefTableBase< FROM, MAPENTRY >::TableType

Define Reference map.

Need to use index into vector, because location of vector entries is not fixed

Definition at line 57 of file RefTable.h.

template<class FROM, class MAPENTRY>

typedef TableType::iterator RefTableBase< FROM, MAPENTRY >::iterator

Definition of map iterator.

Definition at line 59 of file RefTable.h.

template<class FROM, class MAPENTRY>

typedef TableType::const_iterator RefTableBase< FROM, MAPENTRY >::const_iterator

Definition of map iterator (CONST).

Definition at line 61 of file RefTable.h.

## Constructor & Destructor Documentation

template<class FROM, class MAPENTRY>

RefTableBase< FROM, MAPENTRY >::RefTableBase | ( | const CLID & | clid,
|  | int | len |
| ) |  |  | `[inline]`

Constructors.

Definition at line 97 of file RefTable.h.

    00097                                           : m_clid(clid), m_table(len)   {
    00098   }

template<class FROM, class MAPENTRY>

virtual RefTableBase< FROM, MAPENTRY >::~RefTableBase | ( |  | ) | `[inline, virtual]`

Destructor.

Definition at line 100 of file RefTable.h.

    00100                            {
    00101     clear();
    00102   }

## Member Function Documentation

template<class FROM, class MAPENTRY>

bool RefTableBase< FROM, MAPENTRY >::insertMapElement | ( | const KeyType * | from,
|  | EntryType & | to |
| ) |  |  | `[inline, protected]`

Insert new Entry into Reference container.

Definition at line 75 of file RefTable.h.

    00075                                                                   {
    00076     return m_table.insert( from, to );
    00077   }

template<class FROM, class MAPENTRY>

EntryType* RefTableBase< FROM, MAPENTRY >::i_reference | ( | const KeyType * | from | ) | `[inline, protected]`

Find Reference from it's source entry.

Definition at line 79 of file RefTable.h.

    00079                                                {
    00080     iterator i = m_table.find( from );
    00081     if ( i != 0 )    {
    00082       return &((*i).second);
    00083     }
    00084     return 0;
    00085   }

template<class FROM, class MAPENTRY>

const EntryType* RefTableBase< FROM, MAPENTRY >::i_reference | ( | const KeyType * | from | ) | const`[inline, protected]`

Find Reference from it's source entry (CONST).

Definition at line 87 of file RefTable.h.

    00087                                                             {
    00088     const_iterator i = m_table.find( from );
    00089     if ( i != m_table.end() )    {
    00090       return &((*i).second);
    00091     }
    00092     return 0;
    00093   }

template<class FROM, class MAPENTRY>

virtual void RefTableBase< FROM, MAPENTRY >::clear | ( |  | ) | `[inline, virtual]`

Clear Reference map.

Definition at line 104 of file RefTable.h.

    00104                           {
    00105     m_table.clear();
    00106   }

template<class FROM, class MAPENTRY>

iterator RefTableBase< FROM, MAPENTRY >::begin | ( |  | ) | `[inline]`

Start of direct access iterator.

Definition at line 108 of file RefTable.h.

    00108                      {
    00109     return m_table.begin();
    00110   }

template<class FROM, class MAPENTRY>

const_iterator RefTableBase< FROM, MAPENTRY >::begin | ( |  | ) | const`[inline]`

Start of direct access iterator (CONST).

Definition at line 112 of file RefTable.h.

    00112                                  {
    00113     return m_table.begin();
    00114   }

template<class FROM, class MAPENTRY>

iterator RefTableBase< FROM, MAPENTRY >::end | ( |  | ) | `[inline]`

End of direct access iterator.

Definition at line 116 of file RefTable.h.

    00116                    {
    00117     return m_table.end();
    00118   }

template<class FROM, class MAPENTRY>

const_iterator RefTableBase< FROM, MAPENTRY >::end | ( |  | ) | const`[inline]`

End of direct access iterator (CONST).

Definition at line 120 of file RefTable.h.

    00120                                {
    00121     return m_table.end();
    00122   }

template<class FROM, class MAPENTRY>

long RefTableBase< FROM, MAPENTRY >::size | ( |  | ) | const`[inline]`

Size of References.

Definition at line 124 of file RefTable.h.

    00124                         {
    00125     return m_table.size();
    00126   }

template<class FROM, class MAPENTRY>

void RefTableBase< FROM, MAPENTRY >::reserve | ( | int | len | ) | `[inline]`

Size of References.

Definition at line 128 of file RefTable.h.

    00128                           {
    00129     m_table.reserve(len);
    00130   }

template<class FROM, class MAPENTRY>

virtual StreamBuffer& RefTableBase< FROM, MAPENTRY >::serialize | ( | StreamBuffer & | s | ) | const`[inline, virtual]`

Serialize the object for writing.

Reimplemented from DataObject.

Definition at line 132 of file RefTable.h.

    00132                                                              {
    00133     DataObject::serialize(s) << m_table.size();
    00134     //for (TableType::const_iterator i = m_table.begin(), stop = m_table.end(); i != stop; i++ )    {
    00135     //  SmartRef<KeyType> fromRef;
    00136     //  fromRef = (KeyType*)(*i).first;
    00137     //  s << fromRef(this);
    00138     //  s << (*i).second(this);
    00139     //}
    00140     return s;
    00141   }

template<class FROM, class MAPENTRY>

virtual StreamBuffer& RefTableBase< FROM, MAPENTRY >::serialize | ( | StreamBuffer & | s | ) | `[inline, virtual]`

Serialize the object for reading.

Reimplemented from DataObject.

Definition at line 143 of file RefTable.h.

    00143                                                              {
    00144     long siz;
    00145     DataObject::serialize(s) >> siz;
    00146     m_table.reserve(siz);
    00147     //for ( long i = 0; i < siz; i++ )   {
    00148     //  SmartRef<KeyType> fromRef;
    00149     //  EntryType entry;
    00150     //  s >> fromRef(this);
    00151     //  s >> entry(this);
    00152     //  insertMapElement( fromRef, entry);
    00153     //}
    00154     return s;
    00155   }

## Member Data Documentation

template<class FROM, class MAPENTRY>

CLID RefTableBase< FROM, MAPENTRY >::m_clid

Class id of the reference table.

Definition at line 63 of file RefTable.h.

template<class FROM, class MAPENTRY>

TableType RefTableBase< FROM, MAPENTRY >::m_table`[private]`

Reference map.

Definition at line 66 of file RefTable.h.

template<class FROM, class MAPENTRY>

SmartRef<KeyType> RefTableBase< FROM, MAPENTRY >::m_fromRef`[private]`

This is a completely useless entry, but the compiler wants it to be instantiated before the serialize function is defined.

Definition at line 71 of file RefTable.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r10p1/GaudiKernel/GaudiKernel/RefTable.h