inet::physicallayer::LinearIntplMappingIterator Class Reference

Helper-class for the MultiDimMapping which provides an Iterator which linear interpolates between two other Mapping iterators. More...

#include <MappingUtils.h>

Inheritance diagram for inet::physicallayer::LinearIntplMappingIterator:

Public Member Functions
	LinearIntplMappingIterator (ConstMappingIterator *leftIt, ConstMappingIterator *rightIt, argument_value_cref_t f)
	Initializes the Iterator with the passed Iterators of the mappings to Interpolate and the their interpolation-factor. More...
virtual	~LinearIntplMappingIterator ()
	Deletes the left and the right mapping iterator. More...
virtual bool	hasNext () const override
	An interpolated mapping isn't really iterateable over specific values, it only provides an fast way to get several values from an Interpolated mapping. More...
virtual bool	inRange () const override
	An interpolated mapping isn't really iterateable over specific values, it only provides an fast way to get several values from an Interpolated mapping. More...
virtual void	jumpToBegin () override
	This method isn't supported by an interpolated Mapping. More...
virtual void	next () override
	This method isn't supported by an interpolated Mapping. More...
virtual void	setValue (argument_value_cref_t) override
	This method isn't supported by an interpolated Mapping. More...
virtual void	jumpTo (const Argument &pos) override
	Lets the iterator point to the passed position. More...
virtual void	iterateTo (const Argument &pos) override
	Increases the iterator to the passed position. More...
virtual argument_value_t	getValue () const override
	Returns the value of the Interpolated mapping at the current position of the iterator. More...
virtual const Argument &	getPosition () const override
	Returns the current position of the iterator. More...
virtual const Argument &	getNextPosition () const override
	This method isn't supported by an interpolated mapping. More...
Public Member Functions inherited from inet::physicallayer::MappingIterator
	MappingIterator ()
virtual	~MappingIterator ()
Public Member Functions inherited from inet::physicallayer::ConstMappingIterator
	ConstMappingIterator ()
virtual	~ConstMappingIterator ()
	ConstMappingIterator (const ConstMappingIterator &)
	Copy constructor. More...
ConstMappingIterator &	operator= (const ConstMappingIterator &)
	ConstMappingIterator assignment operator. More...
void	swap (ConstMappingIterator &)
	Swaps data with another ConstMappingIterator. More...

Protected Attributes
ConstMappingIterator *	leftIt
	Iterator for the left Mapping to interpolate. More...
ConstMappingIterator *	rightIt
	Iterator for the right Mapping to interpolate. More...
argument_value_t	factor
	The factor defining how strong the left and the right Mapping affect the interpolation. More...

Private Member Functions
	LinearIntplMappingIterator (const LinearIntplMappingIterator &)
	Copy constructor is not allowed. More...
LinearIntplMappingIterator &	operator= (const LinearIntplMappingIterator &)
	Assignment operator is not allowed. More...

Additional Inherited Members
Public Types inherited from inet::physicallayer::ConstMappingIterator
typedef Argument::mapped_type	argument_value_t
typedef Argument::mapped_type_cref	argument_value_cref_t

Detailed Description

Helper-class for the MultiDimMapping which provides an Iterator which linear interpolates between two other Mapping iterators.

Or in other words, it provides an Iterator for an linear interpolated Mapping.

Author

Karl Wessel

Constructor & Destructor Documentation

inet::physicallayer::LinearIntplMappingIterator::LinearIntplMappingIterator ( const LinearIntplMappingIterator &  )

private

Copy constructor is not allowed.

inet::physicallayer::LinearIntplMappingIterator::LinearIntplMappingIterator	(	ConstMappingIterator *	leftIt,
		ConstMappingIterator *	rightIt,
		Mapping::argument_value_cref_t	f
	)

Initializes the Iterator with the passed Iterators of the mappings to Interpolate and the their interpolation-factor.

                                                                                                                                                  :
    MappingIterator(), leftIt(leftIt), rightIt(rightIt), factor(f)
{
    assert(leftIt->getPosition() == rightIt->getPosition());
}

inet::physicallayer::LinearIntplMappingIterator::~LinearIntplMappingIterator ( )

virtual

Deletes the left and the right mapping iterator.

{
    if (leftIt)
        delete leftIt;
    if (rightIt)
        delete rightIt;
}

Member Function Documentation

virtual const Argument& inet::physicallayer::LinearIntplMappingIterator::getNextPosition ( ) const

inlineoverridevirtual

This method isn't supported by an interpolated mapping.

Implements inet::physicallayer::ConstMappingIterator.

{ assert(false); return *((Argument *)nullptr); }

virtual const Argument& inet::physicallayer::LinearIntplMappingIterator::getPosition ( ) const

inlineoverridevirtual

Returns the current position of the iterator.

Constant complexity.

Implements inet::physicallayer::ConstMappingIterator.

    {
        return leftIt->getPosition();
    }

virtual argument_value_t inet::physicallayer::LinearIntplMappingIterator::getValue ( ) const

inlineoverridevirtual

Returns the value of the Interpolated mapping at the current position of the iterator.

This method has constant complexity.

Implements inet::physicallayer::ConstMappingIterator.

    {
        argument_value_cref_t v0 = leftIt->getValue();
        argument_value_cref_t v1 = rightIt->getValue();
        return v0 + (v1 - v0) * factor;
    }

virtual bool inet::physicallayer::LinearIntplMappingIterator::hasNext ( ) const

inlineoverridevirtual

An interpolated mapping isn't really iterateable over specific values, it only provides an fast way to get several values from an Interpolated mapping.

Implements inet::physicallayer::ConstMappingIterator.

{ return false; }

virtual bool inet::physicallayer::LinearIntplMappingIterator::inRange ( ) const

inlineoverridevirtual

An interpolated mapping isn't really iterateable over specific values, it only provides an fast way to get several values from an Interpolated mapping.

Implements inet::physicallayer::ConstMappingIterator.

{ return false; }

virtual void inet::physicallayer::LinearIntplMappingIterator::iterateTo ( const Argument &  pos )

inlineoverridevirtual

Increases the iterator to the passed position.

This position should be near the current position of the iterator.

The passed position has to be compared bigger than the current position.

This method has linear complexity over the number of key entries between the current and the passed position in both underlying mappings used to interpolate. So if the passed position is near the current position this method has nearly constant complexity.

Implements inet::physicallayer::ConstMappingIterator.

    {
        leftIt->iterateTo(pos);
        rightIt->iterateTo(pos);
    }

virtual void inet::physicallayer::LinearIntplMappingIterator::jumpTo ( const Argument &  pos )

inlineoverridevirtual

Lets the iterator point to the passed position.

This method has logarithmic complexity over both of the underlying Mappings used to interpolate.

Implements inet::physicallayer::ConstMappingIterator.

    {
        leftIt->jumpTo(pos);
        rightIt->jumpTo(pos);
    }

virtual void inet::physicallayer::LinearIntplMappingIterator::jumpToBegin ( )

inlineoverridevirtual

This method isn't supported by an interpolated Mapping.

Implements inet::physicallayer::ConstMappingIterator.

{ assert(false); }

virtual void inet::physicallayer::LinearIntplMappingIterator::next ( )

inlineoverridevirtual

This method isn't supported by an interpolated Mapping.

Implements inet::physicallayer::ConstMappingIterator.

{ assert(false); }

LinearIntplMappingIterator& inet::physicallayer::LinearIntplMappingIterator::operator= ( const LinearIntplMappingIterator &  )

private

Assignment operator is not allowed.

virtual void inet::physicallayer::LinearIntplMappingIterator::setValue ( argument_value_cref_t  )

inlineoverridevirtual

This method isn't supported by an interpolated Mapping.

Implements inet::physicallayer::MappingIterator.

{ assert(false); }

Member Data Documentation

argument_value_t inet::physicallayer::LinearIntplMappingIterator::factor

protected

The factor defining how strong the left and the right Mapping affect the interpolation.

ConstMappingIterator* inet::physicallayer::LinearIntplMappingIterator::leftIt

protected

Iterator for the left Mapping to interpolate.

Referenced by ~LinearIntplMappingIterator().

ConstMappingIterator* inet::physicallayer::LinearIntplMappingIterator::rightIt

protected

Iterator for the right Mapping to interpolate.

Referenced by ~LinearIntplMappingIterator().

---

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

• MappingUtils.h
• MappingUtils.cc