abstractgraph.h

/* Evoplex <https://evoplex.org>
 * Copyright (C) 2016-present - Marcos Cardinot <marcos@cardinot.net>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ABSTRACT_GRAPH_H
#define ABSTRACT_GRAPH_H

#include <QtDebug>
#include <QMutex>

#include "abstractplugin.h"
#include "attrsgenerator.h"
#include "edges.h"
#include "enum.h"
#include "nodes.h"

namespace evoplex {

class AbstractGraphInterface : public AbstractPlugin
{
public:
    virtual ~AbstractGraphInterface() = default;

    using AbstractPlugin::init;

    virtual bool reset() = 0;
};

class AbstractGraph : public AbstractGraphInterface
{
    friend class Trial;

public:

    const QString& id() const;

    GraphType type() const;

    inline bool isDirected() const;

    inline bool isUndirected() const;

    inline const Edges& edges() const;

    inline const Edge& edge(int edgeId) const;

    inline const Edge& edge(int originId, int neighbourId) const;

    inline const Nodes& nodes() const;

    inline Node node(int nodeId) const;

    Node randNode() const;

    inline int numNodes() const;

    inline int numEdges() const;

    inline Node addNode(Attributes attr);

    Node addNode(Attributes attr, float x, float y);

    inline Edge addEdge(int originId, int neighbourId, Attributes* attrs=new Attributes());

    Edge addEdge(const Node& origin, const Node& neighbour, Attributes* attrs=new Attributes());

    void removeAllEdges();

    void removeAllEdges(const Node& node);

    void removeNode(const Node& node);

    Nodes::iterator removeNode(Nodes::iterator it);

    void removeEdge(const Edge& edge);

    Edges::iterator removeEdge(Edges::iterator it);

protected:
    AttrsGeneratorPtr m_edgeAttrsGen;
    Edges m_edges;
    Nodes m_nodes;

    AbstractGraph();

private:
    int m_lastNodeId;
    int m_lastEdgeId;
    QMutex m_mutex;

    std::uniform_int_distribution<int> m_numNodesDist;

    bool setup(Trial& trial, AttrsGeneratorPtr edgeGen,
               const Attributes& attrs, Nodes& nodes);
};


/************************************************************************
   AbstractGraph: Inline member functions
 ************************************************************************/

inline bool AbstractGraph::isDirected() const
{ return type() == GraphType::Directed; }

inline bool AbstractGraph::isUndirected() const
{ return type() == GraphType::Undirected; }

inline const Edges& AbstractGraph::edges() const
{ return m_edges; }

inline const Nodes& AbstractGraph::nodes() const
{ return m_nodes; }

inline const Edge& AbstractGraph::edge(int edgeId) const
{ return m_edges.at(edgeId); }

inline const Edge& AbstractGraph::edge(int originId, int neighbourId) const
{ return m_nodes.at(originId).outEdges().at(neighbourId); }

inline Node AbstractGraph::node(int nodeId) const
{ return m_nodes.at(nodeId); }

inline int AbstractGraph::numEdges() const
{ return static_cast<int>(m_edges.size()); }

inline int AbstractGraph::numNodes() const
{ return static_cast<int>(m_nodes.size()); }

inline Node AbstractGraph::addNode(Attributes attr)
{ return addNode(attr, 0, m_lastNodeId+1); }

inline Edge AbstractGraph::addEdge(int originId, int neighbourId, Attributes* attrs)
{  return addEdge(m_nodes.at(originId), m_nodes.at(neighbourId), attrs); }

} // evoplex
#endif // ABSTRACT_GRAPH_H