FindModule.h

#ifndef FIND_MODULE_H
#define FIND_MODULE_H

#include <omnetpp.h>

template<typename T = cModule * const >
class FindModule
{
    public:
        static T findSubModule(const cModule * const top)
        {
            for (cModule::SubmoduleIterator i(top); !i.end(); i++)
            {
                cModule * const sub = i();
                // this allows also a return type of read only pointer: const cModule *const
                T dCastRet = dynamic_cast<T>(sub);
                if (dCastRet != NULL)
                    return dCastRet;
                // this allows also a return type of read only pointer: const cModule *const
                T recFnd = findSubModule(sub);
                if (recFnd != NULL)
                    return recFnd;
            }
            return NULL;
        }

        static T findGlobalModule()
        {
            return findSubModule(simulation.getSystemModule());
        }

        static cModule* findHost(cModule * const m)
        {
            cModule* parent = m != NULL ? m->getParentModule() : NULL;
            cModule* node = m;

            // all nodes should be a sub module of the simulation which has no parent module!!!
            while (parent != NULL && parent->getParentModule() != NULL)
            {
                node = parent;
                parent = node->getParentModule();
            }
            return node;
        }
        static cModule* findNetwork(cModule * const m)
        {
            cModule* node = findHost(m);

            return node ? node->getParentModule() : node;
        }
        // the constness version
        static const cModule* findHost(const cModule * const m)
        {
            const cModule* parent = m != NULL ? m->getParentModule() : NULL;
            const cModule *node = m;

            // all nodes should be a sub module of the simulation which has no parent module!!!
            while (parent != NULL && parent->getParentModule() != NULL)
            {
                node = parent;
                parent = node->getParentModule();
            }
            return node;
        }
        static const cModule* findNetwork(const cModule * const m)
        {
            const cModule* node = findHost(m);

            return node ? node->getParentModule() : node;
        }
};

template<typename T = cModule>
class AccessModuleWrap
{
    public:
        typedef T wrapType;
    private:
        T* pModule;
        AccessModuleWrap(const AccessModuleWrap<T>&);
        AccessModuleWrap<T>& operator=(const AccessModuleWrap<T>&);

    public:
        AccessModuleWrap() :
                pModule(NULL)
        {
        }

        virtual ~AccessModuleWrap()
        {
        }
        ;

        T* get(cModule * const from = NULL)
        {
            if (!pModule)
            {
                pModule = FindModule<T*>::findSubModule(
                        FindModule<>::findHost(from != NULL ? from : simulation.getContextModule()));
            }
            return pModule;
        }
};

#endif