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

Abstract base class for implementing access to a sequence. More...

#include <signals.h>

List of all members.

Public Types
typedef Stor	storage_type
typedef Accs	access_type
typedef Val	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
	SignalSequenceBase (iterator iterStart, iterator iterEnd, storage_type &seq)
	SignalSequenceBase (storage_type &seq)
virtual	~SignalSequenceBase ()=0
SignalSequenceBase< value_type, attributes_type, container_type, storage_type, access_type > &	operator= (const SignalSequenceBase< value_type, attributes_type, container_type, storage_type, access_type > &seq)
reference	operator[] (size_t i)
const_reference	operator[] (size_t i) const
size_t	size () const
size_t	capacity () const
virtual void	resize (size_t i)
void	seek (iterator newStart, iterator newEnd)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
attributes_type &	wAttributes ()
const attributes_type &	rAttributes () const
bool	isAttributesLocked () const
Protected Member Functions
	SignalSequenceBase ()
void	seek (iterator newStart, iterator newEnd, storage_type &storage)

---

Detailed Description

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

Abstract base class for implementing access to 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, 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 Val, class Attr, class Cont> typedef Stor simth::SignalSequenceBase< Val, Attr, Cont >::storage_type

The referenced storage class. Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, and simth::LlvSeq.

template<class Val, class Attr, class Cont> typedef Accs simth::SignalSequenceBase< Val, Attr, Cont >::access_type

The referenced access class. Reimplemented in simth::SignalSequence< Val, Attr, Cont >, and simth::LlvSeq.

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

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

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

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

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

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont> typedef container_type::iterator simth::SignalSequenceBase< Val, Attr, Cont >::iterator

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont> typedef container_type::const_iterator simth::SignalSequenceBase< Val, Attr, Cont >::const_iterator

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont> typedef container_type::reference simth::SignalSequenceBase< Val, Attr, Cont >::reference

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont> typedef container_type::const_reference simth::SignalSequenceBase< Val, Attr, Cont >::const_reference

Reimplemented in simth::SignalSequence< Val, Attr, Cont >, simth::SignalSequenceAccess< Val, Attr, Cont >, simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

---

Constructor & Destructor Documentation

template<class Val, class Attr, class Cont, class Stor, class Accs> simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::SignalSequenceBase (  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 Val, class Attr, class Cont, class Stor, class Accs> simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::SignalSequenceBase (  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 Val, class Attr, class Cont, class Stor, class Accs> simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::~SignalSequenceBase (   )  [pure virtual]

Default destructor. (Pure virtual to force an abstract class.)

template<class Val, class Attr, class Cont, class Stor, class Accs> simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::SignalSequenceBase (   )  [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 Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs > & simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::operator= (  const SignalSequenceBase< 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.

template<class Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::reference simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::operator[] (  size_t  i  )  [inline]

Direct Element access. For iterating through the sequence, you might consider using the iterators instead of this operator.

template<class Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::const_reference simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::operator[] (  size_t  i  )  const [inline]

Direct Element access. For iterating through the sequence, you might consider using the iterators instead of this operator.

template<class Val, class Attr, class Cont> size_t simth::SignalSequenceBase< Val, Attr, Cont >::size (   )  const [inline]

Returns the size of the sequence. This is always smaller or equal to the size of the referenced underlying storage object.

template<class Val, class Attr, class Cont> size_t simth::SignalSequenceBase< Val, Attr, Cont >::capacity (   )  const [inline]

Returns the capapcity of the sequence. The capacity is fixed to the initial size of the sequence. Since resizing the sequence is only possible to sizes smaller or equal the capacity, the capacity always exceeds or equals the size of the sequence. Reimplemented in simth::SignalSequenceStorage< Val, Attr, Cont >, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont, class Stor, class Accs> void simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::resize (  size_t  i  )  [virtual]

Resize this sequence. Watch out: If this object is a SignalSequenceAccess: Resizing is only allowed to a smaller or equal size than what the SignalSequenceAccess was when it was created. Resizing to something bigger is not allowed at all and a std::runtime_exception will be thrown. Resizing to a smaller size does not resize the referenced underlying storage object. Instead, only the references are changed so that this object points to a smaller part of the underlying storage object. If this object is a SignalSequenceStorage: Resizing will simply work just as it does with STL containers. WATCH OUT: After resizing, all iterators, shallow copies, and SignalSequenceAccess objects to this sequence might have become invalid. You must take care that no other shallow copy keeps around old pointers/iterators. Those will be invalid if the sequence has been truncated, or if the sequence has grown larger and thus moved to a different place in memory. Reimplemented in simth::SignalSequenceStorage< Val, Attr, Cont >, simth::LlvSeq, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont, class Stor, class Accs> void simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::seek (  iterator  newStart, iterator  newEnd )

Set this sequence to point to a new start and end. It is the caller's responsibility that both given iterators belong to the sequence that belongs to this shallow copy

template<class Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::iterator simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::begin (   )  [inline]

Returns an iterator pointing to the start of this sequence.

template<class Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::const_iterator simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::begin (   )  const [inline]

Returns a const iterator pointing to the start of this sequence.

template<class Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::iterator simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::end (   )  [inline]

Returns an iterator pointing to the end of this sequence.

template<class Val, class Attr, class Cont, class Stor, class Accs> SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::const_iterator simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::end (   )  const [inline]

Returns a const iterator pointing to the end of this sequence.

template<class Val, class Attr, class Cont> attributes_type& simth::SignalSequenceBase< Val, Attr, Cont >::wAttributes (   )  [inline]

Returns a reference to the attributes class of the sequence. Use this pointer obtain write access. If the referenced storage object holds a lock on the attributes, this function will throw an Error. (If you only need read access to the class use the function rAttributes().) Reimplemented in simth::SignalSequenceStorage< Val, Attr, Cont >, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont> const attributes_type& simth::SignalSequenceBase< Val, Attr, Cont >::rAttributes (   )  const [inline]

Returns a constant reference to the attributes class of the sequence. Use this pointer obtain read only access. (If you need write acces to the class use the function wAttributes(). Reimplemented in simth::SignalSequenceStorage< Val, Attr, Cont >, and simth::LlvSeqStorage.

template<class Val, class Attr, class Cont> bool simth::SignalSequenceBase< Val, Attr, Cont >::isAttributesLocked (   )  const [inline]

Returns true if the attributes are locked, otherwise false.

template<class Val, class Attr, class Cont, class Stor, class Accs> void simth::SignalSequenceBase< Val, Attr, Cont, Stor, Accs >::seek (  iterator  newStart, iterator  newEnd, storage_type &  storage )  [protected]

Set this sequence to point to a new start and end. It is the caller's responsibility that both given iterators belong to the sequence storage is pointing at.

---