topology.h

#ifndef TOPOLOGY_H
#define TOPOLOGY_H

#include "property-container.h"
#include "node.h"
#include "edge.h"
#include "pair.h"

#include <map>
#include <set>
#include <utility>
#include <string>
#include <exception>

namespace fnss {

class Topology : public PropertyContainer {
public:
        Topology(bool directed = false);

        bool isDirected() const;

        void addNode(const std::string &id, const Node &node);

        Node removeNode(const std::string &id, bool pruneEdges = true);

        Node getNode(const std::string &id) const;

        bool hasNode(const std::string &id) const;

        std::set<std::string> getAllNodes() const;

        void addEdge(const std::string &id1, const std::string &id2, const Edge &edge);

        void addEdge(const std::pair<std::string, std::string> &nodes_, const Edge &edge);

        void addEdge(const Pair<std::string, std::string> &nodes_, const Edge &edge);

        Edge removeEdge(const std::string &id1, const std::string &id2);

        Edge removeEdge(const std::pair <std::string, std::string> &nodes_);

        Edge removeEdge(const Pair <std::string, std::string> &nodes_);

        Edge getEdge(const std::string &id1, const std::string &id2) const;

        Edge getEdge(const std::pair <std::string, std::string> &nodes_) const;

        Edge getEdge(const Pair <std::string, std::string> &nodes_) const;

        bool hasEdge(const std::string &id1, const std::string &id2) const;

        bool hasEdge(const std::pair <std::string, std::string> &nodes_) const;

        bool hasEdge(const Pair <std::string, std::string> &nodes_) const;

        std::set<std::pair <std::string, std::string> > getAllEdges() const;

        unsigned int nodeCount() const;

        unsigned int edgeCount() const;

        class EdgeNotFoundException : public std::exception {
        public:
                EdgeNotFoundException(const Pair<std::string, std::string> nodes_) throw() {
                        this->exceptionStr = "The edge between nodes with IDs " + nodes_.first + " and "
                                                                + nodes_.second + " was not found.";
                }

                ~EdgeNotFoundException() throw() {
                }

                const char* what() const throw() {
                        return this->exceptionStr.c_str();
                }

        private:
                std::string exceptionStr;
        };

        class NodeNotFoundException : public std::exception {
        public:
                NodeNotFoundException(const std::string &id) throw() {
                        this->exceptionStr = "The node with ID " + id + " was not found.";
                }

                ~NodeNotFoundException() throw() {
                }

                const char* what() const throw() {
                        return this->exceptionStr.c_str();
                }

        private:
                std::string exceptionStr;
        };

private:
        // Map from node ID to node.
        typedef std::map <std::string, Node> nodesType;
        nodesType nodes;

        // Map from the ID of link end-points to the edge.
        typedef std::map <Pair <std::string, std::string>, Edge> edgesType;
        edgesType edges;

        bool directed;  // Whether the topology is directed.

};

} //namespace

#endif //TOPOLOGY_H