opp_component_ptr.h

//==========================================================================
//   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 "ccomponent.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)));
    }
 
  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;}
 
    bool operator==(const T *ptr) {return ptr == this->ptr;}
 
    bool operator==(const opp_component_ptr<T>& other) {return ptr == other.ptr;}
 
    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;}
};
 
}  // namespace omnetpp
 
#endif