opp_component_ptr.h Source File¶

API: opp_component_ptr.h Source File
API
//==========================================================================
//   OPP_COMPONENT_PTR.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_OPP_COMPONENT_PTR_H
#define __OMNETPP_OPP_COMPONENT_PTR_H
 
#include "cmodule.h"
#include "cexception.h"
 
namespace omnetpp {
template <typename T>
class SIM_API opp_component_ptr
{
  private:
    T *ptr = nullptr;
 
    void registerPtr() {
        if (ptr) {
            if (cComponent *component = dynamic_cast<cComponent*>(ptr))
                component->registerSelfPointer(ptr);
            else
                throw cRuntimeError("opp_component_ptr<%s>: Pointer cannot be dynamic_cast to cComponent", opp_typename(typeid(T)));
        }
    }
 
    void deregisterPtr() {
        if (ptr)
            dynamic_cast<cComponent*>(ptr)->deregisterSelfPointer(ptr);
    }
 
    void checkNull() const {
        if (ptr == nullptr)
            throw cRuntimeError("opp_component_ptr<%s>: Cannot dereference nullptr", opp_typename(typeid(T)));
    }
 
    void doResolveFromPar(cModule *context, const char *parName, bool optional) {
        const char *methodName = optional ? "resolveFromParOptional" : "resolveFromPar";
        if (!context)
            throw cRuntimeError("opp_component_ptr<%s>::%s(): context module is nullptr", opp_typename(typeid(T)), methodName);
        if (!parName)
            throw cRuntimeError("opp_component_ptr<%s>::%s(): parameter name is nullptr", opp_typename(typeid(T)), methodName);
        const char *path = context->par(parName).stringValue();
        if (!*path) {
            if (!optional)
                throw cRuntimeError("opp_component_ptr<%s>::%s(): parameter '%s' of module '(%s)%s' is empty",
                        opp_typename(typeid(T)), methodName, parName, context->getClassName(), context->getFullPath().c_str());
            *this = nullptr;
            return;
        }
        cModule *mod = context->findModuleByPath(path);
        if (!mod)
            throw cRuntimeError("opp_component_ptr<%s>::%s(): module '%s' not found, referenced by parameter '%s' of module '(%s)%s'",
                    opp_typename(typeid(T)), methodName, path, parName, context->getClassName(), context->getFullPath().c_str());
        T *t = dynamic_cast<T *>(mod);
        if (!t)
            throw cRuntimeError("opp_component_ptr<%s>::%s(): module '(%s)%s' resolved from parameter '%s' of module '(%s)%s' cannot be cast to type '%s'",
                    opp_typename(typeid(T)), methodName, mod->getClassName(), mod->getFullPath().c_str(), parName, context->getClassName(), context->getFullPath().c_str(), opp_typename(typeid(T)));
        *this = t;
    }
 
    cGate *doResolveFromGate(cGate *gate, int direction, bool optional) {
        const char *methodName = optional ? "resolveFromGateOptional" : "resolveFromGate";
        if (!gate)
            throw cRuntimeError("opp_component_ptr<%s>::%s(): gate is nullptr", opp_typename(typeid(T)), methodName);
 
        bool forward;
        if (direction > 0)
            forward = true;
        else if (direction < 0)
            forward = false;
        else if (gate->getType() == cGate::OUTPUT)
            forward = true;
        else if (gate->getType() == cGate::INPUT)
            forward = false;
        else
            throw cRuntimeError("opp_component_ptr<%s>::%s(): cannot determine direction for gate '%s'",
                    opp_typename(typeid(T)), methodName, gate->getFullPath().c_str());
 
        cGate *g = forward ? gate->getNextGate() : gate->getPreviousGate();
        while (g) {
            if (T *t = dynamic_cast<T *>(g->getOwnerModule())) {
                *this = t;
                return g;
            }
            g = forward ? g->getNextGate() : g->getPreviousGate();
        }
 
        if (!optional)
            throw cRuntimeError("opp_component_ptr<%s>::%s(): no module of type '%s' found along the connection path from gate '%s'",
                    opp_typename(typeid(T)), methodName, opp_typename(typeid(T)), gate->getFullPath().c_str());
        *this = nullptr;
        return nullptr;
    }
 
  public:
    opp_component_ptr() {}
    opp_component_ptr(T *ptr) : ptr(ptr) {registerPtr();}
    opp_component_ptr(const opp_component_ptr<T>& other) : ptr(other.ptr) {registerPtr();}
    ~opp_component_ptr() {deregisterPtr();}
    T& operator*() const {checkNull(); return *ptr;}
    T *operator->() const {checkNull(); return ptr;}
    operator T *() const {return ptr;}
    explicit operator bool() const {return ptr != nullptr;}
    void operator=(T *newPtr) {
        if (ptr != newPtr) {
            deregisterPtr();
            ptr = newPtr;
            registerPtr();
        }
    }
    void operator=(const opp_component_ptr<T>& ref) {*this = ref.ptr;}
    T *get() const {checkNull(); return ptr;}
    T *getNullable() const {return ptr;}
    void resolveFromParOptional(cModule *context, const char *parName) {
        doResolveFromPar(context, parName, true);
    }
    void resolveFromPar(cModule *context, const char *parName) {
        doResolveFromPar(context, parName, false);
    }
    cGate *resolveFromGateOptional(cGate *gate, int direction = 0) {
        return doResolveFromGate(gate, direction, true);
    }
    cGate *resolveFromGate(cGate *gate, int direction = 0) {
        return doResolveFromGate(gate, direction, false);
    }
};
 
}  // namespace omnetpp
 
#endif
 