Defines it values by concatenating one or more Mappings to a reference Mapping. More...

#include <MappingUtils.h>

Inheritance diagram for inet::physicallayer::ConcatConstMapping< Operator >:

Public Member Functions
	ConcatConstMapping (const ConcatConstMapping &o)

ConcatConstMapping &	operator= (const ConcatConstMapping &copy)
	ConcatConstMapping assignment operator. More...

void	swap (ConcatConstMapping &s)
	Swaps data with another ConcatConstMapping. More...

template<class Iterator >
	ConcatConstMapping (ConstMapping *refMapping, Iterator first, Iterator last, bool continueOutOfRange=true, Argument::mapped_type_cref oorValue=Argument::MappedZero, Operator op=Operator())
	Initializes with the passed reference Mapping, the operator and the Mappings defined by the passed iterator. More...

	ConcatConstMapping (ConstMapping refMapping, ConstMapping other, bool continueOutOfRange=true, Argument::mapped_type_cref oorValue=Argument::MappedZero, Operator op=Operator())
	Initializes with the passed reference Mapping, the operator and another Mapping to concatenate. More...

virtual	~ConcatConstMapping ()

void	addMapping (ConstMapping *m)
	Adds another Mapping to the list of Mappings to concatenate. More...

virtual Argument::mapped_type	getValue (const Argument &pos) const override
	Returns the value of this Mapping at the position specified by the passed Argument. More...

Mapping *	createConcatenatedMapping () const
	Returns the concatenated Mapping. More...

virtual ConstMappingIterator *	createConstIterator () const override
	Returns a pointer of a new Iterator which is able to iterate over this Mapping. More...

virtual ConstMappingIterator *	createConstIterator (const Argument &pos) const override
	Returns a pointer of a new Iterator which is able to iterate over the function. More...

virtual ConstMapping *	constClone () const override
	returns a deep copy of this mapping instance. More...

ConstMapping *	getRefMapping ()
	Returns the pointer to the reference mapping. More...

Public Member Functions inherited from inet::physicallayer::ConstMapping
ConstMapping &	operator= (const ConstMapping &copy)
	ConstMapping assignment operator. More...

void	swap (ConstMapping &s)
	Swaps data with another ConstMapping. More...

	ConstMapping ()
	Initializes the ConstMapping with a the time dimension as domain. More...

	ConstMapping (const ConstMapping &o)

	ConstMapping (const DimensionSet &dimSet)
	Initializes the ConstMapping with the passed DimensionSet as Domain. More...

virtual	~ConstMapping ()

argument_value_t	operator[] (const Argument &pos) const
	Returns the value of this Mapping at the position specified by the passed Argument. More...

const DimensionSet &	getDimensionSet () const
	Returns this Mappings domain as DimensionSet. More...

template<class stream >
stream &	print (stream &out, argument_value_cref_t lTimeScale=argument_value_t(1), argument_value_cref_t lLeftColScale=Argument::MappedOne, const std::string &sTableHead=std::string("o\\ms"), const Dimension *const pOnlyDim=nullptr) const
	Prints the Mapping to an output stream. More...

Protected Types
typedef std::pair< Dimension, Argument::const_iterator >	DimIteratorPair

typedef std::list< ConstMapping * >	MappingSet

Protected Attributes
MappingSet	mappings

ConstMapping *	refMapping

bool	continueOutOfRange

Argument::mapped_type	oorValue

Operator	op

Protected Attributes inherited from inet::physicallayer::ConstMapping
DimensionSet	dimensions
	The dimensions of this mappings domain. More...

Additional Inherited Members
Public Types inherited from inet::physicallayer::ConstMapping
typedef Argument::mapped_type	argument_value_t

typedef Argument::mapped_type_cref	argument_value_cref_t

Detailed Description

template<class Operator>
class inet::physicallayer::ConcatConstMapping< Operator >

Defines it values by concatenating one or more Mappings to a reference Mapping.

Author: Karl Wessel

Member Typedef Documentation

template<class Operator>

typedef std::pair<Dimension, Argument::const_iterator> inet::physicallayer::ConcatConstMapping< Operator >::DimIteratorPair

protected

template<class Operator>

typedef std::list<ConstMapping *> inet::physicallayer::ConcatConstMapping< Operator >::MappingSet

protected

Constructor & Destructor Documentation

template<class Operator>

inet::physicallayer::ConcatConstMapping< Operator >::ConcatConstMapping ( const ConcatConstMapping< Operator > & o )

inline

         : ConstMapping(o)
         , mappings(o.mappings)
         , refMapping(nullptr)
         , continueOutOfRange(o.continueOutOfRange)
         , oorValue(o.oorValue)
         , op()
     {}

template<class Operator>

template<class Iterator >

inet::physicallayer::ConcatConstMapping< Operator >::ConcatConstMapping	(	ConstMapping *	refMapping,
		Iterator	first,
		Iterator	last,
		bool	continueOutOfRange = `true`,
		Argument::mapped_type_cref	oorValue = `Argument::MappedZero`,
		Operator	op = `Operator()`
	)

inline

Initializes with the passed reference Mapping, the operator and the Mappings defined by the passed iterator.

                                       :
         ConstMapping(refMapping->getDimensionSet()),
         mappings(),
         refMapping(refMapping),
         continueOutOfRange(continueOutOfRange),
         oorValue(oorValue),
         op(op)
     {
         while (first != last) {
             mappings.push_back(*first);
             ++first;
         }
     }

template<class Operator>

inet::physicallayer::ConcatConstMapping< Operator >::ConcatConstMapping	(	ConstMapping *	refMapping,
		ConstMapping *	other,
		bool	continueOutOfRange = `true`,
		Argument::mapped_type_cref	oorValue = `Argument::MappedZero`,
		Operator	op = `Operator()`
	)

inline

Initializes with the passed reference Mapping, the operator and another Mapping to concatenate.

                                       :
         ConstMapping(refMapping->getDimensionSet()),
         mappings(),
         refMapping(refMapping),
         continueOutOfRange(continueOutOfRange),
         oorValue(oorValue),
         op(op)
     {
         mappings.push_back(other);
     }

template<class Operator>

virtual inet::physicallayer::ConcatConstMapping< Operator >::~ConcatConstMapping ( )

inlinevirtual

2606 { delete refMapping; }

inet::physicallayer::ConcatConstMapping::refMapping

ConstMapping * refMapping

Definition: MappingUtils.h:2514

Member Function Documentation

template<class Operator>

void inet::physicallayer::ConcatConstMapping< Operator >::addMapping ( ConstMapping * m )

inline

Adds another Mapping to the list of Mappings to concatenate.

     {
         mappings.push_back(m);
     }

template<class Operator>

virtual ConstMapping* inet::physicallayer::ConcatConstMapping< Operator >::constClone ( ) const

inlineoverridevirtual

returns a deep copy of this mapping instance.

Implements inet::physicallayer::ConstMapping.

     {
         return new ConcatConstMapping(*this);
     }

template<class Operator>

Mapping* inet::physicallayer::ConcatConstMapping< Operator >::createConcatenatedMapping ( ) const

inline

Returns the concatenated Mapping.

     {
         assert(!mappings.empty());
 
         MappingSet::const_iterator it = mappings.begin();
         const MappingSet::const_iterator itEnd = mappings.end();
 
         Mapping *result = MappingUtils::applyElementWiseOperator(*refMapping, **it, op,
                     oorValue, continueOutOfRange);
 
         while (++it != itEnd) {
             Mapping *buf = result;
             result = MappingUtils::applyElementWiseOperator(*buf, **it, op,
                         oorValue, continueOutOfRange);
             delete buf;
         }
 
         return result;
     }

template<class Operator>

virtual ConstMappingIterator* inet::physicallayer::ConcatConstMapping< Operator >::createConstIterator ( ) const

inlineoverridevirtual

Returns a pointer of a new Iterator which is able to iterate over this Mapping.

See class ConstIterator for details.

Implements inet::physicallayer::ConstMapping.

     {
         if (mappings.empty()) {
             return refMapping->createConstIterator();
         }
         return new ConcatConstMappingIterator(createConcatenatedMapping());
     }

template<class Operator>

virtual ConstMappingIterator* inet::physicallayer::ConcatConstMapping< Operator >::createConstIterator ( const Argument & pos ) const

inlineoverridevirtual

Returns a pointer of a new Iterator which is able to iterate over the function.

The iterator starts at the passed position.

See class ConstIterator for details.

Implements inet::physicallayer::ConstMapping.

     {
         if (mappings.empty()) {
             return refMapping->createConstIterator(pos);
         }
         return new ConcatConstMappingIterator(createConcatenatedMapping(), pos);
     }

template<class Operator>

ConstMapping* inet::physicallayer::ConcatConstMapping< Operator >::getRefMapping ( )

inline

Returns the pointer to the reference mapping.

     {
         return refMapping;
     }

template<class Operator>

virtual Argument::mapped_type inet::physicallayer::ConcatConstMapping< Operator >::getValue ( const Argument & pos ) const

inlineoverridevirtual

Returns the value of this Mapping at the position specified by the passed Argument.

The complexity of this method depends on the actual implementation.

Implements inet::physicallayer::ConstMapping.

     {
         const MappingSet::const_iterator itEnd = mappings.end();
         Argument::mapped_type res = refMapping->getValue(pos);
 
         for (MappingSet::const_iterator it = mappings.begin(); it != itEnd; ++it) {
             res = op(res, (*it)->getValue(pos));
         }
 
         return res;
     }

template<class Operator>

ConcatConstMapping& inet::physicallayer::ConcatConstMapping< Operator >::operator= ( const ConcatConstMapping< Operator > & copy )

inline

ConcatConstMapping assignment operator.

Parameters

copy	A ConcatConstMapping of identical element and allocator types.

All the elements of copy are copied.

     {
         ConcatConstMapping tmp(copy);    // All resource all allocation happens here.
                                          // If this fails the copy will throw an exception
                                          // and 'this' object is unaffected by the exception.
         swap(tmp);
         return *this;
     }

template<class Operator>

void inet::physicallayer::ConcatConstMapping< Operator >::swap ( ConcatConstMapping< Operator > & s )

inline

Swaps data with another ConcatConstMapping.

Parameters

s	A ConcatConstMapping of the same element and allocator types.

This exchanges the elements between two ConcatConstMapping's in constant time. Note that the global std::swap() function is specialized such that std::swap(s1,s2) will feed to this function.

     {
         ConstMapping::swap(s);    // swap the base class members
         /* Swap all D members */
         std::swap(mappings, s.mappings);
         std::swap(refMapping, s.refMapping);
         std::swap(continueOutOfRange, s.continueOutOfRange);
         std::swap(oorValue, s.oorValue);
         std::swap(op, s.op);
     }