ctopology.h

//==========================================================================
//  CTOPOLOGY.H - part of
//                     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_CTOPOLOGY_H
#define __OMNETPP_CTOPOLOGY_H
 
#include <string>
#include <vector>
#include "cownedobject.h"
#include "csimulation.h"
#include "cmodule.h"
#include "cgate.h"
 
namespace omnetpp {
 
class cPar;
 
// not all compilers define INFINITY (gcc does)
#ifndef INFINITY
#define INFINITY HUGE_VAL
#endif
 
class SIM_API cTopology : public cOwnedObject
{
  public:
    class Link;
    class LinkIn;
    class LinkOut;
 
    class SIM_API Node
    {
        friend class cTopology;
 
      protected:
        int moduleId;
        double weight;
        bool enabled;
        std::vector<Link*> inLinks;
        std::vector<Link*> outLinks;
 
        // variables used by the shortest-path algorithms
        double dist;
        Link *outPath;
 
      public:
        Node(int moduleId=-1) {this->moduleId=moduleId; weight=0; enabled=true; dist=INFINITY; outPath=nullptr;}
        virtual ~Node() {}
 
 
        int getModuleId() const  {return moduleId;}
 
        cModule *getModule() const  {return getSimulation()->getModule(moduleId);}
 
        double getWeight() const  {return weight;}
 
        void setWeight(double d)  {weight=d;}
 
        bool isEnabled() const  {return enabled;}
 
        void enable()  {enabled=true;}
 
        void disable()  {enabled=false;}
 
 
        int getNumInLinks() const  {return inLinks.size();}
 
        LinkIn *getLinkIn(int i);
 
        int getNumOutLinks() const  {return outLinks.size();}
 
        LinkOut *getLinkOut(int i);
 
 
        double getDistanceToTarget() const  {return dist;}
 
        int getNumPaths() const  {return outPath?1:0;}
 
        LinkOut *getPath(int) const  {return (LinkOut *)outPath;}
    };
 
 
    class SIM_API Link
    {
        friend class cTopology;
 
      protected:
        Node *srcNode;
        int srcGateId;
        Node *destNode;
        int destGateId;
        double weight;
        bool enabled;
 
      public:
        Link(double weight=1) {srcNode=destNode=nullptr; srcGateId=destGateId=-1; this->weight=weight; enabled=true;}
        virtual ~Link() {}
 
        double getWeight() const  {return weight;}
 
        void setWeight(double d)  {weight=d;}
 
        bool isEnabled() const  {return enabled;}
 
        void enable()  {enabled=true;}
 
        void disable()  {enabled=false;}
    };
 
 
    class SIM_API LinkIn : public Link
    {
      private:
        LinkIn(double weight=1) : Link(weight) {}
 
      public:
        Node *getRemoteNode() const  {return srcNode;}
 
        Node *getLocalNode() const  {return destNode;}
 
        int getRemoteGateId() const  {return srcGateId;}
 
        int getLocalGateId() const  {return destGateId;}
 
        cGate *getRemoteGate() const  {return srcNode->getModule()->gate(srcGateId);}
 
        cGate *getLocalGate() const  {return destNode->getModule()->gate(destGateId);}
    };
 
 
    class SIM_API LinkOut : public Link
    {
      private:
        LinkOut(double weight=1) : Link(weight) {}
 
      public:
        Node *getRemoteNode() const  {return destNode;}
 
        Node *getLocalNode() const  {return srcNode;}
 
        int getRemoteGateId() const  {return destGateId;}
 
        int getLocalGateId() const  {return srcGateId;}
 
        cGate *getRemoteGate() const  {return destNode->getModule()->gate(destGateId);}
 
        cGate *getLocalGate() const  {return srcNode->getModule()->gate(srcGateId);}
    };
 
    class SIM_API Predicate
    {
      public:
        virtual ~Predicate() {}
        virtual bool matches(cModule *module) = 0;
    };
 
  protected:
    std::vector<Node*> nodes;
    Node *target = nullptr;
 
    // note: the purpose of the (unsigned int) cast is that nodes with moduleId==-1 are inserted at the end of the vector
    static bool lessByModuleId(Node *a, Node *b) { return (unsigned int)a->moduleId < (unsigned int)b->moduleId; }
    static bool isModuleIdLess(Node *a, int moduleId) { return (unsigned int)a->moduleId < (unsigned int)moduleId; }
 
    void unlinkFromSourceNode(Link *link);
    void unlinkFromDestNode(Link *link);
 
  private:
    virtual void parsimPack(cCommBuffer *) const override {throw cRuntimeError(this, E_CANTPACK);}
    virtual void parsimUnpack(cCommBuffer *) override {throw cRuntimeError(this, E_CANTPACK);}
 
  public:
 
    explicit cTopology(const char *name=nullptr);
 
    cTopology(const cTopology& topo);
 
    virtual ~cTopology();
 
    cTopology& operator=(const cTopology& topo);
 
 
    virtual cTopology *dup() const override  {return new cTopology(*this);}
 
    virtual std::string str() const override;
 
 
    virtual void extractFromNetwork(bool (*selfunc)(cModule *,void *), void *userdata=nullptr);
 
    virtual void extractFromNetwork(Predicate *predicate);
 
    virtual void extractByModulePath(const std::vector<std::string>& fullPathPatterns);
 
    virtual void extractByNedTypeName(const std::vector<std::string>& nedTypeNames);
 
    virtual void extractByProperty(const char *propertyName, const char *value=nullptr);
 
    virtual void extractByParameter(const char *paramName, const char *paramValue=nullptr);
 
    virtual void clear();
 
    virtual int addNode(Node *node);
 
    virtual void deleteNode(Node *node);
 
    virtual void addLink(Link *link, Node *srcNode, Node *destNode);
 
    virtual void addLink(Link *link, cGate *srcGate, cGate *destGate);
 
    virtual void deleteLink(Link *link);
 
 
 
    virtual int getNumNodes() const  {return nodes.size();}
 
    virtual Node *getNode(int i) const;
 
    virtual Node *getNodeFor(cModule *mod) const;
 
    /*
     * To be implemented:
     *    -  void unweightedMultiShortestPathsTo(Node *target);
     *    -  void weightedMultiShortestPathsTo(Node *target);
     */
 
    virtual void calculateUnweightedSingleShortestPathsTo(Node *target);
 
    virtual void calculateWeightedSingleShortestPathsTo(Node *target);
 
    virtual Node *getTargetNode() const {return target;}
 
  protected:
    virtual Node *createNode(cModule *module) { return new Node(module->getId()); }
 
    virtual Link *createLink() { return new Link(); }
};
 
}  // namespace omnetpp
 
#endif