fwData/include/fwData/Graph.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2018.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#pragma once

#include "fwData/config.hpp"
#include "fwData/Edge.hpp"
#include "fwData/factory/new.hpp"
#include "fwData/Node.hpp"
#include "fwData/Object.hpp"

#include <map>
#include <set>

fwCampAutoDeclareDataMacro((fwData)(Graph), FWDATA_API);

namespace fwData
{
class FWDATA_CLASS_API Graph : public ::fwData::Object
{

public:
    fwCoreClassDefinitionsWithFactoryMacro( (Graph)(::fwData::Object), (()), ::fwData::factory::New< Graph >);

    fwCampMakeFriendDataMacro((fwData)(Graph));

    FWDATA_API static const bool UP_STREAM;
    FWDATA_API static const bool DOWN_STREAM;

    typedef std::map< Edge::sptr,  std::pair<  Node::sptr,  Node::sptr > > ConnectionContainer;
    typedef std::set< Node::sptr >                                         NodeContainer;  //  Be careful, if you change
                                                                                           // we use erase(it++)

    typedef std::vector< ::fwData::Object::sptr > UpdatedDataType;

    typedef ::fwCom::Signal< void (UpdatedDataType, UpdatedDataType ) > UpdatedSignalType;

    FWDATA_API Graph(::fwData::Object::Key key);

    FWDATA_API virtual ~Graph();

    FWDATA_API bool addNode( Node::sptr _node);

    FWDATA_API bool removeNode( Node::csptr _node);

    FWDATA_API NodeContainer& getNodes();
    FWDATA_API const NodeContainer& getNodes() const;

    FWDATA_API const ConnectionContainer& getConnections() const;
    FWDATA_API ConnectionContainer& getConnections();

    FWDATA_API bool addEdge(Edge::sptr _edge, Node::csptr _nodeSource, Node::csptr _nodeDestination);

    FWDATA_API
    Edge::sptr makeConnection(  Node::csptr _nodeSource,
                                std::string _nodeSourceOutputPortID,
                                Node::csptr _nodeDestination,
                                std::string _nodeDestinationInputPortID,
                                std::string _EdgeNature
                                );

    FWDATA_API bool removeEdge(Edge::sptr _edge);

    FWDATA_API Node::sptr getSourceNode(Edge::sptr _edge);

    FWDATA_API Node::sptr getDestinationNode(Edge::sptr _edge);

    FWDATA_API Node::sptr getNode(Edge::sptr _edge, bool _upStream);

    FWDATA_API std::vector< Edge::sptr > getInputEdges(Node::csptr _node);

    FWDATA_API std::vector< Edge::sptr > getOutputEdges(Node::csptr _node);

    FWDATA_API std::vector< Edge::sptr > getEdges(const Node::csptr& _node, bool _upStream,
                                                  const std::string& _nature = "",
                                                  const std::string& _portID = "");

    FWDATA_API std::vector< ::fwData::Node::sptr > getNodes( const ::fwData::Node::csptr& node, bool upStream,
                                                             const std::string& nature = "",
                                                             const std::string& portID = "" );

    FWDATA_API size_t getNbNodes() const;

    FWDATA_API size_t getNbEdges() const;

    FWDATA_API void shallowCopy( const Object::csptr& _source ) override;

    FWDATA_API void cachedDeepCopy(const Object::csptr& _source, DeepCopyCacheType& cache) override;

    FWDATA_API bool haveConnectedEdges(Node::csptr _node ) const;

    FWDATA_API static const ::fwCom::Signals::SignalKeyType s_UPDATED_SIG;

protected:

    NodeContainer m_nodes;
    ConnectionContainer m_connections;

    UpdatedSignalType::sptr m_sigUpdated;
};

} // namespace fwData