inet::ModuleRefByPar< T > Class Template Reference

This template class implements a module reference that is parameterized by a string module parameter of the referencing module. More...

#include <ModuleRefByPar.h>

Public Member Functions
T &	operator* () const
T *	operator-> () const
	operator T* () const
	operator bool () const
T *	getNullable ()
const T *	getNullable () const
T *	get ()
const T *	get () const
void	reference (cModule *referencingModule, const char *parameterName, bool mandatory)

Private Member Functions
void	checkReference () const

Private Attributes
opp_component_ptr< T >	referencedModule
cModule *	referencingModule = nullptr
const char *	parameterName = nullptr

Detailed Description

template<typename T>
class inet::ModuleRefByPar< T >

This template class implements a module reference that is parameterized by a string module parameter of the referencing module.

The reference can be set by providing the referencing module and the name of the module parameter. After the reference is set, it can be used similarly to a simple C++ pointer. The pointer is automatically set to nullptr when the referenced module is deleted.

TODO follow parameter change

Member Function Documentation

checkReference()

template<typename T >

void inet::ModuleRefByPar< T >::checkReference ( ) const

inlineprivate

                                {
#ifndef NDEBUG
        if (referencedModule.getNullable() == nullptr) {
            if (referencingModule == nullptr)
                throw cRuntimeError("Dereferencing uninitialized reference of type '%s'", opp_typename(typeid(T)));
            else
                throw cRuntimeError("Dereferencing nullptr of type '%s' referenced by module '(%s)%s' with a string module parameter '%s'",
                                    opp_typename(typeid(T)), referencingModule->getClassName(), referencingModule->getFullPath().c_str(), parameterName);
 
        }
#else
        if (referencedModule.getNullable() == nullptr)
            throw cRuntimeError("Dereferencing nullptr of type '%s'", opp_typename(typeid(T)));
#endif
    }

get() [1/2]

template<typename T >

T* inet::ModuleRefByPar< T >::get ( )

inline

{ checkReference(); return referencedModule.get(); }

get() [2/2]

template<typename T >

const T* inet::ModuleRefByPar< T >::get ( ) const

inline

{ checkReference(); return referencedModule.get(); }

getNullable() [1/2]

template<typename T >

T* inet::ModuleRefByPar< T >::getNullable ( )

inline

{ return referencedModule.getNullable(); }

getNullable() [2/2]

template<typename T >

const T* inet::ModuleRefByPar< T >::getNullable ( ) const

inline

{ return referencedModule.getNullable(); }

operator bool()

template<typename T >

inet::ModuleRefByPar< T >::operator bool ( ) const

inlineexplicit

{ return (bool)referencedModule; }

operator T*()

template<typename T >

inet::ModuleRefByPar< T >::operator T* ( ) const

inline

                         {
        return referencedModule;
    }

operator*()

template<typename T >

T& inet::ModuleRefByPar< T >::operator* ( ) const

inline

                         {
        checkReference();
        return *referencedModule;
    }

operator->()

template<typename T >

T* inet::ModuleRefByPar< T >::operator-> ( ) const

inline

                          {
        checkReference();
        return referencedModule;
    }

reference()

template<typename T >

void inet::ModuleRefByPar< T >::reference ( cModule *  referencingModule, const char *  parameterName, bool  mandatory  )

inline

                                                                                          {
        if (referencingModule == nullptr)
            throw cRuntimeError("Referencing module is nullptr");
        if (parameterName == nullptr)
            throw cRuntimeError("Parameter name is nullptr");
#ifndef NDEBUG
        if (this->referencingModule != nullptr)
            throw cRuntimeError("Reference is already initialized");
        this->referencingModule = referencingModule;
        this->parameterName = parameterName;
#endif
        auto& parameter = referencingModule->par(parameterName);
        referencedModule = mandatory ? getModuleFromPar<T>(parameter, referencingModule) : findModuleFromPar<T>(parameter, referencingModule);
    }

Member Data Documentation

parameterName

template<typename T >

const char* inet::ModuleRefByPar< T >::parameterName = nullptr

private

referencedModule

template<typename T >

opp_component_ptr<T> inet::ModuleRefByPar< T >::referencedModule

private

referencingModule

template<typename T >

cModule* inet::ModuleRefByPar< T >::referencingModule = nullptr

private

---

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

• ModuleRefByPar.h