Defines an argument for a mapping. More...

#include <MappingBase.h>

Classes
class	key_iterator

Public Types
typedef DimensionSet::value_type	key_type

typedef double	mapped_type

typedef mapped_type	mapped_type_cref

typedef container_type::iterator	iterator
	Iterator type for this set. More...

typedef container_type::const_iterator	const_iterator
	Const-iterator type for this set. More...

Public Member Functions
	Argument (simtime_t_cref timeVal=SIMTIME_ZERO)
	Initialize this argument with the passed value for the time dimension. More...

	Argument (const DimensionSet &dims, simtime_t_cref timeVal=SIMTIME_ZERO)
	Initializes the Argument with the dimensions of the passed DimensionSet set to zero, and the passed value for the time (or zero, if omitted). More...

simtime_t_cref	getTime () const
	Returns the time value of this argument. More...

void	setTime (simtime_t_cref time)
	Changes the time value of this argument. More...

bool	hasArgVal (const Argument::key_type &dim) const
	Returns true if this Argument has a value for the passed Dimension. More...

mapped_type_cref	getArgValue (const Argument::key_type &dim) const
	Returns the value for the specified dimension. More...

void	setArgValue (const Argument::key_type &dim, Argument::mapped_type_cref value)
	Changes the value for the specified dimension. More...

void	setArgValues (const Argument &o, bool ignoreUnknown=false)
	Update the values of this Argument with the values of the passed Argument. More...

bool	isSamePosition (const Argument &other) const
	Returns true if the passed Argument points to the same position. More...

bool	operator== (const Argument &o) const
	Two Arguments are compared equal if they have the same dimensions and the same values. More...

bool	isClose (const Argument &o, Argument::mapped_type_cref epsilon=Argument::mapped_type(0.000001)) const
	Two Arguments are compared close if they have the same dimensions and their values don't differ more then a specific epsilon. More...

bool	operator< (const Argument &o) const
	Returns true if this Argument is smaller then the passed Argument. More...

int	compare (const Argument &o, const DimensionSet *const dims=nullptr) const
	Compares this Argument with the passed Argument in the dimensions of the passed DimensionsSet. More...

DimensionSet	getDimensions () const
	Returns the dimensions this argument is defined over. More...

Argument &	operator= (const Argument &o)
	Fast implementation of the copy-operator then the default implementation. More...

iterator	begin ()
	Returns an iterator to the first argument value in this Argument. More...

const_iterator	begin () const
	Returns an iterator to the first argument value in this Argument. More...

iterator	end ()
	Returns an iterator to the value behind the last argument value. More...

const_iterator	end () const
	Returns an iterator to the value behind the last argument value. More...

iterator	find (const Argument::key_type &dim)
	Returns an iterator to the Argument value for the passed Dimension. More...

const_iterator	find (const Argument::key_type &dim) const
	Returns an iterator to the Argument value for the passed Dimension. More...

iterator	lower_bound (const Argument::key_type &dim)
	Returns an iterator to the first Argument value which dimension compares greater or equal to the passed Dimension. More...

const_iterator	lower_bound (const Argument::key_type &dim) const
	Returns an iterator to the first Argument value which dimension compares greater or equal to the passed Dimension. More...

Static Public Attributes
static const mapped_type	MappedZero = Argument::mapped_type(0)
	Zero value of a Argument value. More...

static const mapped_type	MappedOne = Argument::mapped_type(1)
	One value of a Argument value. More...

Protected Types
typedef std::map< key_type, mapped_type >	container_type

typedef container_type::value_type	value_type

Protected Member Functions
iterator	insertValue (iterator pos, const Argument::value_type &valPair, iterator &itEnd, bool ignoreUnknown=false)
	Inserts the passed value for the passed Dimension into this Argument. More...

Protected Attributes
simtime_t	time
	Stores the time dimension in Omnet's time type. More...

container_type	values
	Maps the dimensions of this Argument to their values. More...

Friends
std::ostream &	operator<< (std::ostream &out, const Argument &d)
	Output operator for Arguments. More...

Detailed Description

Defines an argument for a mapping.

Defines values for a specified set of dimensions, but at least for the time dimension.

Note: Currently an Argument can be maximal defined over ten Dimensions plus the time dimension!

Author: Karl Wessel

Member Typedef Documentation

typedef container_type::const_iterator inet::physicallayer::Argument::const_iterator

Const-iterator type for this set.

typedef std::map<key_type, mapped_type> inet::physicallayer::Argument::container_type

protected

typedef container_type::iterator inet::physicallayer::Argument::iterator

Iterator type for this set.

typedef DimensionSet::value_type inet::physicallayer::Argument::key_type

typedef double inet::physicallayer::Argument::mapped_type

typedef mapped_type inet::physicallayer::Argument::mapped_type_cref

typedef container_type::value_type inet::physicallayer::Argument::value_type

protected

Constructor & Destructor Documentation

inet::physicallayer::Argument::Argument ( simtime_t_cref timeVal = SIMTIME_ZERO )

Initialize this argument with the passed value for the time dimension.

                                          :
     time(timeVal), values()
 {
 }

inet::physicallayer::Argument::Argument	(	const DimensionSet &	dims,
		simtime_t_cref	timeVal = `SIMTIME_ZERO`
	)

Initializes the Argument with the dimensions of the passed DimensionSet set to zero, and the passed value for the time (or zero, if omitted).

                                                                    :
     time(timeVal), values()
 {
     DimensionSet::const_iterator it = dims.begin();
     const DimensionSet::const_iterator itEnd = dims.end();
 
     for (++it; it != itEnd; ++it) {
         values.insert(Argument::value_type(*it, Argument::MappedZero));
     }
 }

Member Function Documentation

iterator inet::physicallayer::Argument::begin ( )

inline

Returns an iterator to the first argument value in this Argument.

Referenced by inet::physicallayer::MappingUtils::findMax(), inet::physicallayer::MappingUtils::findMin(), isClose(), isSamePosition(), inet::physicallayer::ConstMapping::print(), and setArgValues().

643 { return values.begin(); }

inet::physicallayer::Argument::values

container_type values

Maps the dimensions of this Argument to their values.

Definition: MappingBase.h:438

const_iterator inet::physicallayer::Argument::begin ( ) const

inline

Returns an iterator to the first argument value in this Argument.

647 { return values.begin(); }

inet::physicallayer::Argument::values

container_type values

Maps the dimensions of this Argument to their values.

Definition: MappingBase.h:438

int inet::physicallayer::Argument::compare	(	const Argument &	o,
		const DimensionSet *const	dims = `nullptr`
	)		const

Compares this Argument with the passed Argument in the dimensions of the passed DimensionsSet.

(Every other Dimension is asserted equal).

Returns: < 0 - passed Argument is bigger = 0 - Arguments are equal > 0 - passed Argument is smaller

See "operator<" for definition of smaller, equal and bigger.

Referenced by inet::physicallayer::MappingUtils::findMin(), operator<(), and operator==().

 {
     DimensionSet::const_iterator DimItLast;
     if (dims != nullptr)
         DimItLast = dims->end();
     const DimensionSet::const_iterator DimItEnd = DimItLast;
 
     const container_type::const_reverse_iterator rItEnd = values.rend();
     const container_type::const_iterator itEndO = o.values.end();
     container_type::const_reverse_iterator rIt;
     container_type::const_iterator itO;
     bool bDidCompare = false;
 
     //iterate through passed dimensions and compare arguments in these dimensions
     for (container_type::const_reverse_iterator rIt = values.rbegin(); rIt != rItEnd; ++rIt) {
         bool bMissedDimsEntry = false;
 
         if (dims != nullptr) {
             DimensionSet::const_iterator DimItCurr = dims->find(rIt->first);
             if (DimItCurr == DimItEnd) {
                 continue;
             }
             if (DimItLast != DimItEnd && (--DimItLast) != DimItEnd) {
                 bMissedDimsEntry = (DimItLast != DimItCurr);    // missed something
             }
             DimItLast = DimItCurr;
         }
         bDidCompare = true;
         //catch special cases time, missing dimension values (after which we can abort)
         if (bMissedDimsEntry || (itO = o.values.find(rIt->first)) == itEndO) {
             if (time == o.time)
                 return 0;
             return (time < o.time) ? -1 : 1;
         }
 
         //if both Arguments are defined in the current dimensions
         //compare them (otherwise we assume them equal and continue)
         if (rIt->second != itO->second)
             return (rIt->second < itO->second) ? -1 : 1;
     }
     if (dims == nullptr || (dims->find(Dimension::time) != DimItEnd || (!bDidCompare && !dims->empty()))) {
         if (time == o.time)
             return 0;
         return (time < o.time) ? -1 : 1;
     }
     return 0;
 }

iterator inet::physicallayer::Argument::end ( )

inline

Returns an iterator to the value behind the last argument value.

Referenced by inet::physicallayer::MappingUtils::findMax(), inet::physicallayer::MappingUtils::findMin(), isClose(), isSamePosition(), inet::physicallayer::ConstMapping::print(), and setArgValues().

652 { return values.end(); }

inet::physicallayer::Argument::values

container_type values

Maps the dimensions of this Argument to their values.

Definition: MappingBase.h:438

const_iterator inet::physicallayer::Argument::end ( ) const

inline

Returns an iterator to the value behind the last argument value.

656 { return values.end(); }

inet::physicallayer::Argument::values

container_type values

Maps the dimensions of this Argument to their values.

Definition: MappingBase.h:438

Argument::iterator inet::physicallayer::Argument::find ( const Argument::key_type & dim )

Returns an iterator to the Argument value for the passed Dimension.

Returns end() if there is no Argument for that dimension.

Referenced by getArgValue(), and inet::physicallayer::ConstMapping::print().

 {
     assert(!(dim == Dimension::time));
 
     return values.find(dim);
 }

Argument::const_iterator inet::physicallayer::Argument::find ( const Argument::key_type & dim ) const

Returns an iterator to the Argument value for the passed Dimension.

Returns end() if there is no Argument for that dimension.

 {
     assert(!(dim == Dimension::time));
 
     return values.find(dim);
 }

Argument::mapped_type_cref inet::physicallayer::Argument::getArgValue ( const Argument::key_type & dim ) const

Returns the value for the specified dimension.

Note: Don't use this function to get the time value! Use "getTime()" instead.

Returns zero if no value with the specified dimension is set for this argument.

 {
     const_iterator it = find(dim);
 
     if (it == values.end())
         return MappedZero;
 
     return it->second;
 }

DimensionSet inet::physicallayer::Argument::getDimensions ( ) const

inline

Returns the dimensions this argument is defined over.

Note: this method has linear complexity over the number of dimensions, since the DimensionSet has to be created from the values and their dimensions inside this Argument.

Referenced by inet::physicallayer::MappingUtils::findMax(), inet::physicallayer::MappingUtils::findMin(), operator<(), and inet::physicallayer::SimpleConstMappingIterator::SimpleConstMappingIterator().

     {
         typedef key_iterator<const_iterator> key_const_iterator;
 
         DimensionSet res(Dimension::time);
 
         res.insert(key_const_iterator(values.begin()), key_const_iterator(values.end()));
 
         return res;
     }

simtime_t_cref inet::physicallayer::Argument::getTime ( ) const

Returns the time value of this argument.

 {
     return time;
 }

bool inet::physicallayer::Argument::hasArgVal ( const Argument::key_type & dim ) const

Returns true if this Argument has a value for the passed Dimension.

Referenced by inet::physicallayer::MultiDimMapping< Linear >::getValue(), inet::physicallayer::MultiDimMappingIterator< Linear >::iterateTo(), and inet::physicallayer::MultiDimMappingIterator< Linear >::jumpTo().

 {
     return values.find(dim) != values.end();
 }

Argument::iterator inet::physicallayer::Argument::insertValue	(	iterator	pos,
		const Argument::value_type &	valPair,
		iterator &	itEnd,
		bool	ignoreUnknown = `false`
	)

inlineprotected

Inserts the passed value for the passed Dimension into this Argument.

The parameter "pos" defines the position inside the Dimension<->Value-pair array to start searching for the dimension to set.

If the "ignoreUnknown"-parameter is set to true the new value is only set if the Dimension was defined in this Argument before (means, no new DImensions are added to the Argument).

The method returns the position inside the array the value was inserted.

Referenced by setArgValues().

 {
     pos = values.lower_bound(valPair.first);
     if (pos != itEnd && !(values.key_comp()(valPair.first, pos->first))) {
         // key already exists
         // update pos->second if you care to
         pos->second = valPair.second;
         return pos;
     }
     if (ignoreUnknown)
         return pos;
 
     pos = values.insert(pos, valPair);
     itEnd = values.end();
     return pos;
 }

bool inet::physicallayer::Argument::isClose	(	const Argument &	o,
		Argument::mapped_type_cref	epsilon = `Argument::mapped_type(0.000001)`
	)		const

Two Arguments are compared close if they have the same dimensions and their values don't differ more then a specific epsilon.

 {
     if (values.size() != o.values.size())
         return false;
 
     if (fabs(SIMTIME_DBL(time - o.time)) > epsilon)
         return false;
 
     const_iterator itO = o.begin();
     const const_iterator itEnd = end();
     const const_iterator itEndO = o.end();
 
     for (const_iterator it = begin();
          it != itEnd && itO != itEndO; ++it)
     {
         if (!(it->first == itO->first) || (fabs(it->second - itO->second) > epsilon)) {
             return false;
         }
         ++itO;
     }
 
     return true;
 }

bool inet::physicallayer::Argument::isSamePosition ( const Argument & other ) const

Returns true if the passed Argument points to the same position.

The functions returns true if every Dimension in the passed Argument exists in this Argument and their values are the same. The difference to the == operator is that the dimensions of the passed Argument can be a subset of the dimensions of this Argument.

 {
     if (time != o.time) {
         return false;
     }
 
     if (values.size() < o.values.size()) {
         return false;
     }
 
     if (o.values.empty())
         return true;
 
     const_iterator itO = o.begin();
     const_iterator it = begin();
     const const_iterator itEnd = end();
     const const_iterator itEndO = o.end();
 
     while (it != itEnd) {
         if (itO->first < it->first) {
             break;
         }
         else if (it->first < itO->first)
             ++it;
         else {
             if (it->second != itO->second) {
                 break;
             }
             ++it;
             ++itO;
         }
         if (itO == itEndO)
             return true;
     }
 
     return false;
 }

Argument::iterator inet::physicallayer::Argument::lower_bound ( const Argument::key_type & dim )

Returns an iterator to the first Argument value which dimension compares greater or equal to the passed Dimension.

 {
     assert(!(dim == Dimension::time));
 
     return values.lower_bound(dim);
 }

Argument::const_iterator inet::physicallayer::Argument::lower_bound ( const Argument::key_type & dim ) const

Returns an iterator to the first Argument value which dimension compares greater or equal to the passed Dimension.

 {
     assert(!(dim == Dimension::time));
 
     return values.lower_bound(dim);
 }

bool inet::physicallayer::Argument::operator< ( const Argument & o ) const

Returns true if this Argument is smaller then the passed Argument.

The dimensions of the Arguments have to be the same.

An Argument is compared smaller than another Argument if the value of the Dimension with the highest id is compared smaller. If the value of the highest Dimension is compared bigger the Argument isn't compared smaller (method returns false). If the values of the Dimension with the highest Dimension are equal, the next smaller Dimension is compared.

 {
     assert(getDimensions() == o.getDimensions());
 
     return compare(o) < 0;
 }

Argument & inet::physicallayer::Argument::operator= ( const Argument & o )

Fast implementation of the copy-operator then the default implementation.

 {
     values = o.values;
     time = o.time;
     return *this;
 }

bool inet::physicallayer::Argument::operator== ( const Argument & o ) const

Two Arguments are compared equal if they have the same dimensions and the same values.

 {
     if (time != o.time || values.size() != o.values.size())
         return false;
 
     return compare(o) == 0;
 }

void inet::physicallayer::Argument::setArgValue	(	const Argument::key_type &	dim,
		Argument::mapped_type_cref	value
	)

Changes the value for the specified dimension.

Note: Don't use this function to change the time value! Use "setTime()" instead.

If the argument doesn't already contain a value for the specified dimension the new dimension is added.

 {
     assert(!(dim == Dimension::time));
 
     iterator pos = values.lower_bound(dim);
     if (pos != values.end() && !(values.key_comp()(dim, pos->first))) {
         // key already exists
         // update pos->second if you care to
         pos->second = value;
         return;
     }
     values.insert(pos, Argument::value_type(dim, value));
 }

void inet::physicallayer::Argument::setArgValues	(	const Argument &	o,
		bool	ignoreUnknown = `false`
	)

Update the values of this Argument with the values of the passed Argument.

Only the dimensions from the passed Argument are updated or added.

If the ignoreUnknown parameter is set to true, only the Dimensions already inside the Argument are updated.

Referenced by inet::physicallayer::MultiDimMappingIterator< Linear >::iterateTo(), inet::physicallayer::MultiDimMappingIterator< Linear >::jumpTo(), inet::physicallayer::MultiDimMappingIterator< Linear >::jumpToBegin(), inet::physicallayer::MultiDimMappingIterator< Linear >::next(), and inet::physicallayer::MultiDimMappingIterator< Linear >::updateNextPosition().

 {
     time = o.time;
 
     iterator pos = begin();
     const const_iterator oEndIter = o.end();
     iterator EndIter = values.end();
 
     for (const_iterator it = o.begin(); it != oEndIter; ++it) {
         pos = insertValue(pos, *it, EndIter, ignoreUnknown);
         if (ignoreUnknown && pos == EndIter)
             break; //current dimension was not found and next will be also not in our dimension set
     }
 }

void inet::physicallayer::Argument::setTime ( simtime_t_cref time )

Changes the time value of this argument.

 {
     this->time = time;
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	out,
		const Argument &	d
	)

friend

Output operator for Arguments.

Produces output of form "(x1, x2, x3, <...>)".

     {
         using std::operator<<;
 
         out << "(" << d.time;
 
         for (const_iterator it = d.begin(); it != d.end(); ++it) {
             out << ", " << it->second << "@" << it->first;
         }
         return out << ")";
     }

Member Data Documentation

const Argument::mapped_type inet::physicallayer::Argument::MappedOne = Argument::mapped_type(1)

static

One value of a Argument value.

Referenced by inet::physicallayer::LinearIntplMapping::getValue().

const Argument::mapped_type inet::physicallayer::Argument::MappedZero = Argument::mapped_type(0)

static

Zero value of a Argument value.

Referenced by inet::physicallayer::DimensionalAnalogModelBase::computeNoise(), inet::physicallayer::IsotropicDimensionalBackgroundNoise::computeNoise(), inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower(), inet::physicallayer::DimensionalTransmitterBase::createPowerMapping(), getArgValue(), inet::physicallayer::MultiDimMappingIterator< Linear >::getValue(), and inet::physicallayer::MultiDimMapping< Linear >::getValue().

simtime_t inet::physicallayer::Argument::time

protected

Stores the time dimension in Omnet's time type.

Referenced by compare(), getTime(), isClose(), isSamePosition(), operator=(), operator==(), setArgValues(), and setTime().

container_type inet::physicallayer::Argument::values

protected

Maps the dimensions of this Argument to their values.

Referenced by Argument(), compare(), find(), getArgValue(), hasArgVal(), insertValue(), isClose(), isSamePosition(), lower_bound(), operator=(), operator==(), setArgValue(), and setArgValues().

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

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation