ctopology.h

//==========================================================================
//  CTOPOLOGY.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//     cTopology : network topology to find shortest paths etc.
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CTOPOLOGY_H
#define __CTOPOLOGY_H

#include <string>
#include <vector>
#include "cownedobject.h"
#include "csimulation.h"
#include "cmodule.h"
#include "cgate.h"

NAMESPACE_BEGIN

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;

      private:
        int module_id;
        double wgt;
        bool enabl;

        int num_in_links;
        Link **in_links;
        int num_out_links;
        Link *out_links;

        // variables used by the shortest-path algorithms
        double dist;
        Link *out_path;

      public:

        int getModuleId() const  {return module_id;}

        cModule *getModule() const  {return simulation.getModule(module_id);}

        double getWeight() const  {return wgt;}

        void setWeight(double d)  {wgt=d;}

        bool isEnabled() const  {return enabl;}

        void enable()  {enabl=true;}

        void disable()  {enabl=false;}


        int getNumInLinks() const  {return num_in_links;}

        LinkIn *getLinkIn(int i);

        int getNumOutLinks() const  {return num_out_links;}

        LinkOut *getLinkOut(int i);


        double getDistanceToTarget() const  {return dist;}

        int getNumPaths() const  {return out_path?1:0;}

        LinkOut *getPath(int) const  {return (LinkOut *)out_path;}
    };


    class SIM_API Link
    {
        friend class cTopology;

      protected:
        Node *src_node;
        int src_gate;
        Node *dest_node;
        int dest_gate;
        double wgt;
        bool enabl;

      public:
        double getWeight() const  {return wgt;}

        void setWeight(double d)  {wgt=d;}

        bool isEnabled() const  {return enabl;}

        void enable()  {enabl=true;}

        void disable()  {enabl=false;}
    };


    class SIM_API LinkIn : public Link
    {
      public:
        Node *getRemoteNode() const  {return src_node;}

        int getRemoteGateId() const  {return src_gate;}

        int getLocalGateId() const  {return dest_gate;}

        cGate *getRemoteGate() const  {return src_node->getModule()->gate(src_gate);}

        cGate *getLocalGate() const  {return dest_node->getModule()->gate(dest_gate);}
    };


    class SIM_API LinkOut : public Link
    {
      public:
        Node *getRemoteNode() const  {return dest_node;}

        int getRemoteGateId() const  {return dest_gate;}

        int getLocalGateId() const  {return src_gate;}

        cGate *getRemoteGate() const  {return dest_node->getModule()->gate(dest_gate);}

        cGate *getLocalGate() const  {return src_node->getModule()->gate(src_gate);}
    };

    class SIM_API Predicate
    {
      public:
        virtual ~Predicate() {}
        virtual bool matches(cModule *module) = 0;
    };

  protected:
    int num_nodes;
    Node *nodev;
    Node *target;

  public:

    explicit cTopology(const char *name=NULL);

    cTopology(const cTopology& topo);

    virtual ~cTopology();

    cTopology& operator=(const cTopology& topo);


    virtual cTopology *dup() const  {return new cTopology(*this);}

    virtual std::string info() const;

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);


    void extractFromNetwork(bool (*selfunc)(cModule *,void *), void *userdata=NULL);

    void extractFromNetwork(Predicate *predicate);

    void extractByModulePath(const std::vector<std::string>& fullPathPatterns);

    void extractByNedTypeName(const std::vector<std::string>& nedTypeNames);

    void extractByProperty(const char *propertyName, const char *value=NULL);

    void extractByParameter(const char *paramName, const char *paramValue=NULL);

    void clear();


    int getNumNodes() const  {return num_nodes;}

    Node *getNode(int i);

    Node *getNodeFor(cModule *mod);

    /*
     * To be implemented:
     *    -  void unweightedMultiShortestPathsTo(Node *target);
     *    -  void weightedMultiShortestPathsTo(Node *target);
     */

    void calculateUnweightedSingleShortestPathsTo(Node *target);

    void calculateWeightedSingleShortestPathsTo(Node *target);

    Node *getTargetNode() const {return target;}
};

NAMESPACE_END


#endif