Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

simth::SignalSequenceAccess< Val, Attr, Cont > Class Template Reference

Implementation of a shallow copy of a sequence. More...

#include <signals.h>

Inheritance diagram for simth::SignalSequenceAccess< Val, Attr, Cont >:

simth::SignalSequence< Val, Attr, Cont > simth::SignalSequenceBase< Val, Attr, Cont, SignalSequenceStorage< Val, Attr, Cont >, SignalSequenceAccess< Val, Attr, Cont > > List of all members.

Public Types

typedef base_type::value_type value_type
typedef base_type::attributes_type attributes_type
typedef base_type::container_type container_type
typedef base_type::iterator iterator
typedef base_type::const_iterator const_iterator
typedef base_type::reference reference
typedef base_type::const_reference const_reference
typedef base_type::storage_type storage_type

Public Member Functions

 SignalSequenceAccess (iterator iterStart, iterator iterEnd, storage_type &seq)
 SignalSequenceAccess (const SignalSequence< Val, Attr, Cont > &seq)

Detailed Description

template<class Val, class Attr, class Cont>
class simth::SignalSequenceAccess< Val, Attr, Cont >

Implementation of a shallow copy of a sequence.

Note:
Why do we need such a complex structure for the Signal classes? Please read the comment in signals.h for an explanation.
This class behaves similar to a vector of the standard template library (STL), but it does not allocate any storage by itself. Instead, it only represents a shallow copy of another storage allocated elsewhere.

Characteristics: Element access in this class always directly affects the elements of the referenced SignalSequenceStorage class. Resizing to a larger size is not possible and will throw an exception. Resizing to a smaller size does not resize the referenced storage -- instead, the begin/end iterators in this class simply point to a smaller part of the referenced storage.


Member Typedef Documentation

template<class Val, class Attr, class Cont>
typedef base_type::value_type simth::SignalSequenceAccess< Val, Attr, Cont >::value_type
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::attributes_type simth::SignalSequenceAccess< Val, Attr, Cont >::attributes_type
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::container_type simth::SignalSequenceAccess< Val, Attr, Cont >::container_type
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::iterator simth::SignalSequenceAccess< Val, Attr, Cont >::iterator
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::const_iterator simth::SignalSequenceAccess< Val, Attr, Cont >::const_iterator
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::reference simth::SignalSequenceAccess< Val, Attr, Cont >::reference
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::const_reference simth::SignalSequenceAccess< Val, Attr, Cont >::const_reference
 

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.

template<class Val, class Attr, class Cont>
typedef base_type::storage_type simth::SignalSequenceAccess< Val, Attr, Cont >::storage_type
 

The referenced storage class.

Reimplemented from simth::SignalSequence< Val, Attr, Cont >.


Constructor & Destructor Documentation

template<class Val, class Attr, class Cont>
simth::SignalSequenceAccess< Val, Attr, Cont >::SignalSequenceAccess iterator  iterStart,
iterator  iterEnd,
storage_type seq
[inline]
 

This constructor is used to create a shallow copy (or reference copy) of an already existing SignalSequence. This means that the newly created sequence does not allocate new memory for elements, but instead it works on a part of an already existing sequence. Hence the attributes of an object generated with this constructor are also an shallow copy of the original class.

In other words, this constructor is always cheap.

template<class Val, class Attr, class Cont>
simth::SignalSequenceAccess< Val, Attr, Cont >::SignalSequenceAccess const SignalSequence< Val, Attr, Cont > &  seq  )  [inline]
 

Constructor which directly creates a new shallow-copy-sequence of the given SequenceStorage.

This is a cheap constructor, too.


Generated on Mon Apr 24 21:19:20 2006 for simthetic by  doxygen 1.4.1