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;

    // 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);

  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 parsimPack(cCommBuffer *buffer) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) 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);

    virtual Node *getNodeFor(cModule *mod);

    /*
     * 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