Graph.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_PROFILER_GRAP_H
#define YARP_PROFILER_GRAP_H
 
#include<yarp/os/Property.h>
 
#include <iostream>
#include <vector>
#include <string>
 
namespace yarp::profiler::graph {
class Vertex;
class Edge;
class Graph;
class Algorithm;
class GraphicVertex;
class OwnedVertex;
class ProcessVertex;
class PortVertex;
class MachineVertex;
 
} // namespace yarp::profiler::graph
 
 
typedef  std::vector<yarp::profiler::graph::Edge> edge_set;
typedef  edge_set::iterator edge_iterator;
typedef  edge_set::const_iterator edge_const_iterator;
 
typedef  std::vector<yarp::profiler::graph::Vertex*> pvertex_set;
typedef  pvertex_set::iterator pvertex_iterator;
typedef  pvertex_set::const_iterator pvertex_const_iterator;
 
typedef  std::vector<pvertex_set> graph_subset;
typedef  graph_subset::iterator graph_subset_iterator;
typedef  graph_subset::const_iterator graph_subset_const_iterator;
 
 
class yarp::profiler::graph::Edge {
public:
 
    Edge(const yarp::profiler::graph::Vertex& firstV,
         const yarp::profiler::graph::Vertex& secondV,
         yarp::os::Property property="");
 
    Edge(const Edge& edge);
 
    virtual ~Edge();
 
    const yarp::profiler::graph::Vertex& first() const;
    const yarp::profiler::graph::Vertex& second() const;
    virtual bool operator == (const yarp::profiler::graph::Edge &edge) const;
 
public:
    yarp::os::Property property;
 
private:
    const yarp::profiler::graph::Vertex* firstVertex;
    const yarp::profiler::graph::Vertex* secondVertex;
};
 
 
class yarp::profiler::graph::Vertex {
 
public:
    Vertex(const yarp::os::Property &prop);
    Vertex(const yarp::profiler::graph::Vertex& vertex);
    virtual ~Vertex();
 
    const edge_set& outEdges() const { return outs; }
    const edge_set& inEdges() const { return ins; }
    size_t degree() const { return ins.size() + outs.size(); }
 
    virtual bool operator == (const yarp::profiler::graph::Vertex &v1) const = 0;
    virtual bool operator<(const Vertex &v1) const;
 
    friend class Graph;
 
public:
    yarp::os::Property property;
 
private:
    void insertOuts(const yarp::profiler::graph::Edge& edge);
    void insertIns(const yarp::profiler::graph::Edge& edge);
 
private:
    edge_set outs;
    edge_set ins;
};
 
 
class yarp::profiler::graph::Graph {
 
public:
    Graph();
    //Graph(yarp::profiler::graph::Graph& graph);
    virtual ~Graph();
 
    //void insert(Vertex *vertex);
    pvertex_iterator insert(const Vertex &vertex);
    void remove(const Vertex &vertex);
    void remove(const pvertex_iterator vi);
 
    void insertEdge(const Vertex &v1, const Vertex &v2,
                    const yarp::os::Property &property="");
 
    void insertEdge(const pvertex_iterator vi1, const pvertex_iterator vi2,
                    const yarp::os::Property &property="");
 
    const pvertex_iterator find(const Vertex &v1);
 
    size_t size();
    size_t nodesCount();
    const pvertex_set& vertices() { return mVertices; }
    size_t order() { return mVertices.size(); }
 
    void clear();
 
private:
    pvertex_set mVertices;
};
 
 
class yarp::profiler::graph::Algorithm {
public:
    static bool calcSCC(yarp::profiler::graph::Graph& graph, graph_subset &scc);
};
 
class yarp::profiler::graph::GraphicVertex : public yarp::profiler::graph::Vertex
{
public:
        GraphicVertex(const yarp::os::Property &prop) : yarp::profiler::graph::Vertex(prop){
            graphicItem = nullptr;
        }
        void setGraphicItem(void* item) { graphicItem= item; }
        void* getGraphicItem() { return graphicItem; }
 
private:
    void* graphicItem;
};
 
class yarp::profiler::graph::OwnedVertex :  public yarp::profiler::graph::GraphicVertex
{
public:
    OwnedVertex(const yarp::os::Property &prop) : yarp::profiler::graph::GraphicVertex(prop)
    {
        owner = nullptr;
    }
    bool setOwner(yarp::profiler::graph::Vertex* _owner) {
        if (_owner)
        {
            owner = _owner;
            return true;
        }
        return false;
    }
    yarp::profiler::graph::Vertex* getOwner() { return owner; }
private:
    yarp::profiler::graph::Vertex* owner;
 
};
 
class yarp::profiler::graph::PortVertex : public OwnedVertex
{
public:
        PortVertex(const std::string name) : yarp::profiler::graph::OwnedVertex("(type port)") {
            property.put("name", name);
        }
        virtual ~PortVertex(){}
 
        bool operator == (const yarp::profiler::graph::Vertex &v1) const override {
            return property.find("name").asString() == v1.property.find("name").asString();
        }
 
};
 
class yarp::profiler::graph::ProcessVertex : public yarp::profiler::graph::OwnedVertex
{
public:
        ProcessVertex(int pid, const std::string hostname) : yarp::profiler::graph::OwnedVertex("(type process)") {
            property.put("hostname", hostname);
            property.put("pid", pid);
        }
        virtual ~ProcessVertex(){}
 
        bool operator == (const yarp::profiler::graph::Vertex &v1) const override {
            return property.find("hostname").asString() == v1.property.find("hostname").asString() &&
                   property.find("pid").asInt32() == v1.property.find("pid").asInt32();
        }
 
};
 
class yarp::profiler::graph::MachineVertex : public yarp::profiler::graph::GraphicVertex
{
public:
        MachineVertex(std::string os, const std::string hostname) : yarp::profiler::graph::GraphicVertex("(type machine)") {
            property.put("hostname", hostname);
            property.put("os", os);
        }
        virtual ~MachineVertex() {}
 
        bool operator == (const yarp::profiler::graph::Vertex &v1) const override {
            return property.find("hostname").asString() == v1.property.find("hostname").asString() &&
                   property.find("os").asString() == v1.property.find("os").asString() &&
                   property.find("type").asString() == v1.property.find("type").asString() ;
        }
};
 
 
#endif // YARP_PROFILER_GRAP_H