mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs > Class Template Reference

Base class for implementing access to a sequence. More...

#include <matrixseq.h>

Inheritance diagram for mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >:

[legend]List of all members.

Public Types
typedef Stor	storage_type
typedef Accs	access_type
typedef elemT	value_type
typedef Attr	attributes_type
typedef Cont	container_type
typedef container_type::iterator	iterator
typedef container_type::const_iterator	const_iterator
typedef container_type::reference	reference
typedef container_type::const_reference	const_reference
Public Member Functions
	MSequenceBase (iterator iterStart, iterator iterEnd, storage_type &seq)
	MSequenceBase (storage_type &seq)
virtual	~MSequenceBase ()=0
MSequenceBase< value_type, attributes_type, container_type, storage_type, access_type > &	operator= (const MSequenceBase< value_type, attributes_type, container_type, storage_type, access_type > &seq)
Protected Member Functions
	MSequenceBase ()

---

Detailed Description

template<class elemT, class Attr, class Cont, class Stor, class Accs>
class mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >

Base class for implementing access to a sequence.

This class behaves similar to a vector of the standard template library (STL), but it does not allocate any storage by itself, depending on the derived class. Either the derived class in fact allocates storage, in which case this base class is the interface to access it. Or the derived class implements a shallow copy of a 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 only possible if the derived class is a storage object, otherwise it 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 elemT, class Attr, class Cont, class Stor, class Accs> typedef Stor mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::storage_type

The referenced storage class. Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef Accs mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::access_type

The referenced access class. Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef elemT mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::value_type

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef Attr mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::attributes_type

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef Cont mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::container_type

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef container_type::iterator mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::iterator

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef container_type::const_iterator mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::const_iterator

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef container_type::reference mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::reference

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

template<class elemT, class Attr, class Cont, class Stor, class Accs> typedef container_type::const_reference mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::const_reference

Reimplemented from simth::SignalSequenceBase< elemT, Attr, Cont, Stor, Accs >. Reimplemented in mimo::MSequence< elemT, Attr, Cont >, mimo::MSequenceStorage< elemT, Attr, Cont >, and mimo::MSequenceAccess< elemT, Attr, Cont >.

---

Constructor & Destructor Documentation

template<class elemT, class Attr, class Cont, class Stor, class Accs> mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::MSequenceBase (  iterator  iterStart, iterator  iterEnd, storage_type &  seq )

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 elemT, class Attr, class Cont, class Stor, class Accs> mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::MSequenceBase (  storage_type &  seq  )

Copy constructor from another sequence. This object will point to the same underlying storage/deep copy than the given sequence. This constructor is cheap, too.

template<class elemT, class Attr, class Cont, class Stor, class Accs> virtual mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::~MSequenceBase (   )  [pure virtual]

Default destructor.

template<class elemT, class Attr, class Cont, class Stor, class Accs> mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::MSequenceBase (   )  [protected]

Protected standard constructor that does not initalize the storage reference neither it does initialize the internal begin() and end() iterators. Hence the sequence is not ready to use after calling this constuctor without calling the function seek(iter1,iter2,storage).

---

Member Function Documentation

template<class elemT, class Attr, class Cont, class Stor, class Accs> MSequenceBase<value_type, attributes_type, container_type, storage_type, access_type>& mimo::MSequenceBase< elemT, Attr, Cont, Stor, Accs >::operator= (  const MSequenceBase< value_type, attributes_type, container_type, storage_type, access_type > &  seq  )

Deep Copy assignment from another sequence. WATCH OUT -- this may be an expensive operation, since every element is going to be copied.

---