inet::physicallayer::ConstMapping Class Reference

Represents a not changeable mapping (mathematical function) from domain with at least the time to a Argument::mapped_type value. More...

#include <MappingBase.h>

Inheritance diagram for inet::physicallayer::ConstMapping:

Public Types
typedef Argument::mapped_type	argument_value_t
typedef Argument::mapped_type_cref	argument_value_cref_t

Public Member Functions
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 ()
virtual argument_value_t	getValue (const Argument &pos) const =0
	Returns the value of this Mapping at the position specified by the passed Argument. More...
virtual ConstMappingIterator *	createConstIterator () const =0
	Returns a pointer of a new Iterator which is able to iterate over this Mapping. More...
virtual ConstMappingIterator *	createConstIterator (const Argument &pos) const =0
	Returns a pointer of a new Iterator which is able to iterate over the function. More...
virtual ConstMapping *	constClone () const =0
	returns a deep copy of this mapping instance. More...
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 Attributes
DimensionSet	dimensions
	The dimensions of this mappings domain. More...

Private Member Functions
template<class T >
std::string	toString (T v, unsigned int length) const
std::string	toString (simtime_t_cref v, unsigned int length) const

Friends
std::ostream &	operator<< (std::ostream &out, const ConstMapping &rMapToPrint)

Detailed Description

Represents a not changeable mapping (mathematical function) from domain with at least the time to a Argument::mapped_type value.

This class is an interface which describes a mapping (math.) from a arbitrary dimensional domain (represented by a DimensionSet) to a Argument::mapped_type value.

Author

Karl Wessel

Member Typedef Documentation

typedef Argument::mapped_type_cref inet::physicallayer::ConstMapping::argument_value_cref_t

typedef Argument::mapped_type inet::physicallayer::ConstMapping::argument_value_t

Constructor & Destructor Documentation

inet::physicallayer::ConstMapping::ConstMapping ( )

inline

Initializes the ConstMapping with a the time dimension as domain.

                   :
        dimensions(Dimension::time) {}

inet::physicallayer::ConstMapping::ConstMapping ( const ConstMapping &  o )

inline

                                        :
        dimensions(o.dimensions) {}

inet::physicallayer::ConstMapping::ConstMapping ( const DimensionSet &  dimSet )

inline

Initializes the ConstMapping with the passed DimensionSet as Domain.

The passed DimensionSet has to contain the time dimension!

                                             :
        dimensions(dimSet)
    {
//        assert(dimSet.hasDimension(Dimension::time));
    }

virtual inet::physicallayer::ConstMapping::~ConstMapping ( )

inlinevirtual

{}

Member Function Documentation

virtual ConstMapping* inet::physicallayer::ConstMapping::constClone ( ) const

pure virtual

returns a deep copy of this mapping instance.

Implemented in inet::physicallayer::ConcatConstMapping< Operator >, inet::physicallayer::Mapping, inet::physicallayer::ConstMappingWrapper, inet::physicallayer::ConstantSimpleConstMapping, and inet::physicallayer::SimpleTimeConstMapping.

Referenced by inet::physicallayer::ConstMappingWrapper::clone(), and inet::physicallayer::ConstMappingWrapper::constClone().

virtual ConstMappingIterator* inet::physicallayer::ConstMapping::createConstIterator ( ) const

pure virtual

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

See class ConstIterator for details.

Implemented in inet::physicallayer::BaseDelayedMapping< Mapping >, inet::physicallayer::ConcatConstMapping< Operator >, inet::physicallayer::SimpleConstMapping, inet::physicallayer::Mapping, and inet::physicallayer::ConstMappingWrapper.

Referenced by inet::physicallayer::MappingUtils::applyElementWiseOperator(), inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower(), inet::physicallayer::MappingUtils::createCompatibleMapping(), inet::physicallayer::ConstMappingWrapper::createConstIterator(), inet::physicallayer::ConcatConstMapping< Operator >::createConstIterator(), inet::physicallayer::LinearIntplMapping::createIterator(), inet::physicallayer::ConstMappingWrapper::createIterator(), inet::physicallayer::FilledUpMapping::FilledUpMapping(), inet::physicallayer::MappingUtils::findMax(), inet::physicallayer::MappingUtils::findMin(), and print().

virtual ConstMappingIterator* inet::physicallayer::ConstMapping::createConstIterator ( const Argument &  pos ) const

pure virtual

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.

Implemented in inet::physicallayer::BaseDelayedMapping< Mapping >, inet::physicallayer::ConcatConstMapping< Operator >, inet::physicallayer::SimpleConstMapping, inet::physicallayer::Mapping, and inet::physicallayer::ConstMappingWrapper.

const DimensionSet& inet::physicallayer::ConstMapping::getDimensionSet ( ) const

inline

Returns this Mappings domain as DimensionSet.

Referenced by inet::physicallayer::MappingUtils::applyElementWiseOperator(), inet::physicallayer::DimensionalNoise::computeMaxPower(), inet::physicallayer::DimensionalSNIR::computeMin(), inet::physicallayer::DimensionalReception::computeMinPower(), inet::physicallayer::DimensionalSignalAnalogModel::computeMinPower(), inet::physicallayer::DimensionalAnalogModelBase::computeNoise(), inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower(), inet::physicallayer::MappingUtils::createCompatibleMapping(), inet::physicallayer::MappingUtils::findMax(), inet::physicallayer::MappingUtils::findMin(), print(), inet::physicallayer::DimensionalSignalAnalogModel::printToStream(), inet::physicallayer::DimensionalNoise::printToStream(), and inet::physicallayer::DimensionalTransmission::printToStream().

    {
        return dimensions;
    }

virtual argument_value_t inet::physicallayer::ConstMapping::getValue ( const Argument &  pos ) const

pure virtual

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

The complexity of this method depends on the actual implementation.

Implemented in inet::physicallayer::BaseDelayedMapping< Mapping >, inet::physicallayer::ConcatConstMapping< Operator >, inet::physicallayer::MultiDimMapping< Interpolator >, inet::physicallayer::MultiDimMapping< Linear >, inet::physicallayer::ConstMappingWrapper, inet::physicallayer::ConstantSimpleConstMapping, inet::physicallayer::LinearIntplMapping, inet::physicallayer::FrequencyMapping< Interpolator >, inet::physicallayer::TimeMapping< Interpolator >, and inet::physicallayer::SimpleTimeConstMapping.

Referenced by inet::physicallayer::LinearIntplMapping::getValue(), inet::physicallayer::ConstMappingWrapper::getValue(), inet::physicallayer::SimpleConstMappingIterator::getValue(), inet::physicallayer::ConcatConstMapping< Operator >::getValue(), and inet::physicallayer::Ieee802154UWBIRReceiver::integrateWindow().

ConstMapping& inet::physicallayer::ConstMapping::operator= ( const ConstMapping &  copy )

inline

ConstMapping assignment operator.

Parameters

copy	A ConstMapping of identical element and allocator types.

All the elements of copy are copied.

Referenced by inet::physicallayer::Mapping::operator=(), and inet::physicallayer::SimpleConstMapping::operator=().

    {
        dimensions = copy.dimensions;
        return *this;
    }

argument_value_t inet::physicallayer::ConstMapping::operator[] ( const Argument &  pos ) const

inline

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

    {
        return getValue(pos);
    }

template<class stream >

stream& inet::physicallayer::ConstMapping::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

inline

Prints the Mapping to an output stream.

Parameters

out	The output stream to print.
lTimeScale	The scaling factor for the time header values (default 1000).
lLeftColScale	The scaling factor for the left column values (default 1, unscaled).
sTableHead	The header string for the left column (default: "o\\ms").
pOnlyDim	Pointer to a specific dimension which should be used as the left column (should not be the Dimension::time).

Referenced by inet::physicallayer::DimensionalSNIR::computeMin(), inet::physicallayer::DimensionalAnalogModelBase::computeNoise(), and inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower().

    {
        std::ostream::fmtflags outFlags = out.flags();
        const ConstMapping& m = *this;
        DimensionSet::value_type otherDim;
        const DimensionSet& dims = m.getDimensionSet();
        bool bOnlyDimFound = false;

        using std::operator<<;

        std::stringstream osDimHead(std::stringstream::out);
        bool bTimeIsIn = false;
        const auto dimsEnd = dims.end();
        for (auto it = dims.begin(); it != dimsEnd; ++it) {
            if (*it != Dimension::time) {
                if (pOnlyDim && *it == *pOnlyDim) {
                    otherDim = *it;
                    bOnlyDimFound = pOnlyDim != nullptr;
                }
                else if (!pOnlyDim) {
                    otherDim = *it;
                }
                if (!osDimHead.str().empty())
                    osDimHead << ", ";
                osDimHead << *it;
            }
            else
                bTimeIsIn = true;
        }
        if (bTimeIsIn || !osDimHead.str().empty()) {
            out << "Mapping domain: ";
            if (bTimeIsIn) {
                out << "time";
                if (!osDimHead.str().empty())
                    out << ", ";
            }
            out << osDimHead.str() << endl;
        }

        ConstMappingIterator *it = m.createConstIterator();

        if (!it->inRange()) {
            out << "Mapping is empty." << endl;
            out.flags(outFlags);
            delete it;
            return out;
        }

        Argument min = it->getPosition();
        Argument max = it->getPosition();

        typedef std::set<simtime_t> t_time_container_type;
        typedef std::set<argument_value_t> t_value_container_type;

        t_time_container_type timePositions;
        t_value_container_type otherPositions;
        std::size_t iMaxHeaderItemLen = m.toString(it->getPosition().getTime() * lTimeScale, 2).length();
        std::size_t iMaxLeftItemLen = 5 > sTableHead.length() ? 5 : sTableHead.length();
        const bool bIs2Dim = dims.size() == 2;

        if (bIs2Dim && bOnlyDimFound)
            bOnlyDimFound = false; // we have only the time and the requested dimension (fallback to normal case)
        timePositions.insert(it->getPosition().getTime());
        if (bIs2Dim || bOnlyDimFound) {
            Argument::const_iterator posValIt;
            if (bOnlyDimFound && (posValIt = it->getPosition().find(otherDim)) != it->getPosition().end()) {
                otherPositions.insert(it->getPosition().getArgValue(otherDim));
                iMaxLeftItemLen = std::max(iMaxLeftItemLen, m.toString(posValIt->second * lLeftColScale, 2).length());
            }
            else if (!bOnlyDimFound) {
                otherPositions.insert(it->getPosition().begin()->second);
                iMaxLeftItemLen = std::max(iMaxLeftItemLen, m.toString(it->getPosition().begin()->second * lLeftColScale, 2).length());
            }
        }

        while (it->hasNext()) {
            it->next();
            const Argument& pos = it->getPosition();
            const Argument::const_iterator posValItEnd = pos.end();
            Argument::const_iterator posValIt;

            min.setTime(std::min(min.getTime(), pos.getTime()));
            max.setTime(std::max(max.getTime(), pos.getTime()));

            timePositions.insert(pos.getTime());

            iMaxHeaderItemLen = std::max(iMaxHeaderItemLen, m.toString(pos.getTime() * lTimeScale, 2).length());

            if (bOnlyDimFound && (posValIt = pos.find(otherDim)) != posValItEnd) {
                iMaxLeftItemLen = std::max(iMaxLeftItemLen, m.toString(posValIt->second * lLeftColScale, 2).length());
            }
            for (Argument::const_iterator itA = pos.begin(); itA != posValItEnd; ++itA) {
                if (bIs2Dim || bOnlyDimFound) {
                    if (!bOnlyDimFound || itA->first == otherDim) {
                        otherPositions.insert(itA->second);
                        iMaxLeftItemLen = std::max(iMaxLeftItemLen, m.toString(itA->second * lLeftColScale, 2).length());
                    }
                }
                min.setArgValue(itA->first, std::min(min.getArgValue(itA->first), itA->second));
                max.setArgValue(itA->first, std::max(max.getArgValue(itA->first), itA->second));
            }
        }
        delete it;

        if (!bIs2Dim && !bOnlyDimFound) {
            if (!bOnlyDimFound && pOnlyDim != nullptr) {
                out << "map contains no " << pOnlyDim->getName() << " dimension!" << endl;
                out.flags(outFlags);
                return out;
            }
            else
                out << "domain - min=" << min << " max=" << max << endl;
        }
        if (bOnlyDimFound && otherPositions.empty()) {
            out << "Defines no own key entries for " << pOnlyDim->getName() << " dimension! That does NOT mean it doesn't define any attenuation." << endl;
            out.flags(outFlags);
            return out;
        }

        t_time_container_type::const_iterator tIt;
        const t_time_container_type::const_iterator tItEnd = timePositions.end();
        std::stringstream osBorder(std::stringstream::out);
        std::stringstream osHeader(std::stringstream::out);
        mixim::math::mW2dBm<argument_value_t> fctor2dBm;

        for (tIt = timePositions.begin(); tIt != tItEnd; ++tIt) {
            osHeader << m.toString(*tIt * lTimeScale, iMaxHeaderItemLen) << osHeader.fill();
        }
        osBorder.fill('-');
        osBorder << std::setw(iMaxLeftItemLen) << "" << osBorder.fill() << "+" << osBorder.fill() << std::setw(osHeader.str().length()) << "";

        out << osBorder.str() << std::endl;
        out << std::setw(iMaxLeftItemLen) << std::left << sTableHead << out.fill() << "|" << out.fill();
        out << osHeader.str() << std::endl;
        out << osBorder.str() << std::endl;

        it = m.createConstIterator();

        if (dims.size() == 1) {
            out << std::setw(iMaxLeftItemLen) << "value" << out.fill() << "|" << out.fill();
            while (it->inRange()) {
                out << m.toString(fctor2dBm(it->getValue()), iMaxHeaderItemLen) << out.fill();
                if (!it->hasNext()) {
                    break;
                }
                it->next();
            }
        }
        else {
            t_value_container_type::const_iterator fIt = otherPositions.begin();

            tIt = timePositions.begin();
            out << m.toString((*fIt) * lLeftColScale, iMaxLeftItemLen) << out.fill() << "|" << out.fill();
            while (it->inRange()) {
                if (*fIt != it->getPosition().getArgValue(otherDim)) {
                    ++fIt;
                    out << std::endl << m.toString((*fIt) * lLeftColScale, iMaxLeftItemLen) << out.fill() << "|" << out.fill();
                    tIt = timePositions.begin();
                    assert(*fIt == it->getPosition().getArgValue(otherDim));
                }

                while (tIt != tItEnd && *tIt < it->getPosition().getTime()) {
                    // blank item because the header time does not match
                    ++tIt;
                    out << std::setw(iMaxHeaderItemLen + 1) << "";
                }
                if (tIt != tItEnd) {
                    // jump to next header item
                    ++tIt;
                }

                out << m.toString(fctor2dBm(it->getValue()), iMaxHeaderItemLen) << out.fill();

                if (!it->hasNext()) {
                    break;
                }
                it->next();
            }
        }
        delete it;
        out << std::endl << osBorder.str() << std::endl;
        out.flags(outFlags);
        return out;
    }

void inet::physicallayer::ConstMapping::swap ( ConstMapping &  s )

inline

Swaps data with another ConstMapping.

Parameters

s	A ConstMapping of the same element and allocator types.

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

Referenced by inet::physicallayer::Mapping::swap(), inet::physicallayer::SimpleConstMapping::swap(), and inet::physicallayer::ConcatConstMapping< Operator >::swap().

    {
        //::swap(s); // swap the base class members
        /* Swap all D members */
        dimensions.swap(s.dimensions);
    }

template<class T >

std::string inet::physicallayer::ConstMapping::toString ( T  v, unsigned int  length  ) const

inlineprivate

Referenced by print().

    {
        std::stringstream osToStr(std::stringstream::out);

        using std::operator<<;

        osToStr << std::fixed;
        osToStr.precision(16);
        osToStr.width(length);
        osToStr << std::right << v;

        return osToStr.str();
    }

std::string inet::physicallayer::ConstMapping::toString ( simtime_t_cref  v, unsigned int  length  ) const

inlineprivate

    {
        return toString(SIMTIME_DBL(v), length);
    }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  out, const ConstMapping &  rMapToPrint  )

friend

    {
        return rMapToPrint.print(out);
    }

Member Data Documentation

DimensionSet inet::physicallayer::ConstMapping::dimensions

protected

The dimensions of this mappings domain.

Referenced by inet::physicallayer::MultiDimMappingIterator< Linear >::MultiDimMappingIterator(), operator=(), inet::physicallayer::MultiDimMapping< Linear >::operator=(), and swap().

---

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

• MappingBase.h