inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > > Class Template Reference

Specialization of the Linear-template which provides LinearInterpolation for pointer two Mappings. More...

#include <MappingUtils.h>

Inheritance diagram for inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >:

Public Types
typedef base_class_type::storage_type	storage_type
typedef base_class_type::container_type	container_type
typedef base_class_type::key_type	key_type
typedef base_class_type::key_cref_type	key_cref_type
typedef base_class_type::mapped_type	mapped_type
typedef base_class_type::mapped_cref_type	mapped_cref_type
typedef base_class_type::pair_type	pair_type
typedef base_class_type::iterator	iterator
typedef base_class_type::const_iterator	const_iterator
typedef base_class_type::comparator_type	comparator_type
typedef base_class_type::interpolated	interpolated
Public Types inherited from inet::physicallayer::InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >
typedef std::map< Argument::mapped_type, Mapping * >	storage_type
typedef storage_type	container_type
typedef storage_type::key_type	key_type
typedef const key_type &	key_cref_type
typedef storage_type::mapped_type	mapped_type
typedef const mapped_type &	mapped_cref_type
typedef storage_type::value_type	pair_type
typedef storage_type::iterator	iterator
typedef storage_type::const_iterator	const_iterator
typedef PairLess< pair_type, key_type >	comparator_type
typedef Interpolated< mapped_type >	interpolated

Public Member Functions
	Linear ()
	Linear (mapped_cref_type oorv)
	Linear (const _Self &o)
virtual	~Linear ()
virtual interpolated	operator() (const const_iterator &first, const const_iterator &last, key_cref_type pos, const_iterator upperBound) const override
	Functor operator of this class which linear interpolates the value at the passed position using the values between the passed Iterators. More...
Public Member Functions inherited from inet::physicallayer::InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >
	InterpolatorBase ()
	InterpolatorBase (mapped_cref_type oorv)
virtual	~InterpolatorBase ()
bool	continueAtOutOfRange (void) const
interpolated	operator() (const const_iterator &first, const const_iterator &last, key_cref_type pos) const
	Functor operator of this class which interpolates the value at the passed position using the values between the passed Iterators. More...
virtual bool	isStepping () const
	Represents the interpolator a stepping function. More...
void	setOutOfRangeVal (mapped_cref_type oorv)
	Getter and Setter method for out of range value. More...
mapped_cref_type	getOutOfRangeVal (void) const

Protected Types
typedef InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >	base_class_type
typedef Linear< std::map< Argument::mapped_type, Mapping * > >	_Self

Static Protected Member Functions
static ConstMapping::argument_value_t	linearInterpolationFactor (key_cref_type t, key_cref_type t0, key_cref_type t1)
	calculates the linear interpolation factor used for the created LinearIntplMappings. More...

Additional Inherited Members
Public Attributes inherited from inet::physicallayer::InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >
comparator_type	comp
	Comparator for STL functions. More...
Protected Member Functions inherited from inet::physicallayer::InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >
interpolated	asInterpolated (mapped_cref_type rVal, bool bIsOutOfRange, bool bIsInterpolated=true) const
Protected Attributes inherited from inet::physicallayer::InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >
bool	continueOutOfRange
interpolated	outOfRangeVal

Detailed Description

template<>
class inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >

Specialization of the Linear-template which provides LinearInterpolation for pointer two Mappings.

Used by MultiDimMapping.

Author

Karl Wessel

Member Typedef Documentation

typedef Linear<std::map<Argument::mapped_type, Mapping *> > inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::_Self

protected

typedef InterpolatorBase<std::map<Argument::mapped_type, Mapping *> > inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::base_class_type

protected

typedef base_class_type::comparator_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::comparator_type

typedef base_class_type::const_iterator inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::const_iterator

typedef base_class_type::container_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::container_type

typedef base_class_type::interpolated inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::interpolated

typedef base_class_type::iterator inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::iterator

typedef base_class_type::key_cref_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::key_cref_type

typedef base_class_type::key_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::key_type

typedef base_class_type::mapped_cref_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::mapped_cref_type

typedef base_class_type::mapped_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::mapped_type

typedef base_class_type::pair_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::pair_type

typedef base_class_type::storage_type inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::storage_type

Constructor & Destructor Documentation

inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::Linear ( )

inline

             :
        base_class_type() {}

inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::Linear ( mapped_cref_type  oorv )

inline

                                  :
        base_class_type(oorv) {}

inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::Linear ( const _Self &  o )

inline

                           :
        base_class_type(o) {}

virtual inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::~Linear ( )

inlinevirtual

{}

Member Function Documentation

static ConstMapping::argument_value_t inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::linearInterpolationFactor ( key_cref_type  t, key_cref_type  t0, key_cref_type  t1  )

inlinestaticprotected

calculates the linear interpolation factor used for the created LinearIntplMappings.

    {
        assert((t0 <= t && t <= t1) || (t0 >= t && t >= t1));
        if (t0 == t1) {
            return 0;
        }
        return cast_it<ConstMapping::argument_value_t>((t - t0) / (t1 - t0));
    }

virtual interpolated inet::physicallayer::Linear< std::map< Argument::mapped_type, Mapping * > >::operator() ( const const_iterator &  first, const const_iterator &  last, key_cref_type  pos, const_iterator  upperBound  ) const

inlineoverridevirtual

Functor operator of this class which linear interpolates the value at the passed position using the values between the passed Iterators.

The upperBound-iterator has to point two the entry next bigger as the passed position to interpolate.

The returned instance of interpolated represents the result. Which can be either an actual entry of the interpolated map (if the position two interpolate was exactly that. Or it can be an interpolated value, if the passed position was between two entries of the map. This state can be retrieved with the "isInterpolated"-Member of the returned "interpolated".

Implements inet::physicallayer::InterpolatorBase< std::map< Argument::mapped_type, Mapping * > >.

    {
        if (first == last) {
            return base_class_type::outOfRangeVal;
        }
        if (upperBound == first) {
            return asInterpolated(upperBound->second, true);
        }

        const_iterator right = upperBound;
        const_iterator left = --upperBound;

        if (left->first == pos)
            return asInterpolated(left->second, false, false);

        if (right == last) {
            return asInterpolated(left->second, true);
        }

        return interpolated(LinearIntplMapping(left->second, right->second, linearInterpolationFactor(pos, left->first, right->first)));
    }

---

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

• MappingUtils.h