nodeGraphPart.h

Go to the documentation of this file.

#ifndef GUM_NODE_GRAPH_PART_H
#define GUM_NODE_GRAPH_PART_H

#include <algorithm>
#include <utility>

#include <agrum/agrum.h>

#include <agrum/tools/graphs/graphElements.h>

#include <agrum/tools/core/signal/listener.h>
#include <agrum/tools/core/signal/signaler.h>

#ifndef DOXYGEN_SHOULD_SKIP_THIS

namespace gum_tests {

  class NodeGraphPartTestSuite;
}

#endif

namespace gum {

  class NodeGraphPart;

  class NodeGraphPartIterator {
    friend class NodeGraphPart;

    public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = NodeId;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using difference_type = std::ptrdiff_t;

    // ############################################################################
    // ############################################################################

    NodeGraphPartIterator(const NodeGraphPart& nodes) noexcept;

    NodeGraphPartIterator(const NodeGraphPartIterator& it) noexcept;

    NodeGraphPartIterator(NodeGraphPartIterator&& it) noexcept;

    virtual ~NodeGraphPartIterator() noexcept;


    // ############################################################################
    // ############################################################################

    NodeGraphPartIterator& operator=(const NodeGraphPartIterator& it) noexcept;

    NodeGraphPartIterator& operator=(NodeGraphPartIterator&& it) noexcept;

    bool operator==(const NodeGraphPartIterator& it) const noexcept;

    bool operator!=(const NodeGraphPartIterator& it) const noexcept;

    NodeGraphPartIterator& operator++() noexcept;

    value_type operator*() const;


    protected:
    void _setPos(NodeId id) noexcept;

    void _validate() noexcept;

    const NodeGraphPart* _nodes;

    NodeId _pos{0};

    // is this iterator still valid ?
    bool _valid{false};
  };

  class NodeGraphPartIteratorSafe: public NodeGraphPartIterator, public Listener {
    friend class NodeGraphPart;

    public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = NodeId;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using difference_type = std::ptrdiff_t;

    // ############################################################################
    // ############################################################################

    NodeGraphPartIteratorSafe(const NodeGraphPart& nodes);

    NodeGraphPartIteratorSafe(const NodeGraphPartIteratorSafe& it);

    NodeGraphPartIteratorSafe(NodeGraphPartIteratorSafe&& it);

    ~NodeGraphPartIteratorSafe();


    // ############################################################################
    // ############################################################################

    NodeGraphPartIteratorSafe& operator=(const NodeGraphPartIteratorSafe& it);

    NodeGraphPartIteratorSafe& operator=(NodeGraphPartIteratorSafe&& it);


    // ############################################################################
    // ############################################################################


    void whenNodeDeleted(const void* src, NodeId id);

  };

  class NodeGraphPart {
    public:
    using node_iterator = NodeGraphPartIterator;
    using node_const_iterator = NodeGraphPartIterator;
    using node_iterator_safe = NodeGraphPartIteratorSafe;
    using node_const_iterator_safe = NodeGraphPartIteratorSafe;

    // something strange with SWIG (with "using", these definitions cored dump
    // the
    // swig process)
    typedef NodeGraphPartIterator     NodeIterator;
    typedef NodeGraphPartIterator     NodeConstIterator;
    typedef NodeGraphPartIteratorSafe NodeIteratorSafe;
    typedef NodeGraphPartIteratorSafe NodeConstIteratorSafe;

    Signaler1< NodeId > onNodeAdded;
    Signaler1< NodeId > onNodeDeleted;

    // ############################################################################
    // ############################################################################


    explicit NodeGraphPart(Size holes_size = HashTableConst::default_size,
                           bool holes_resize_policy = true);


    NodeGraphPart(const NodeGraphPart& s);

    virtual ~NodeGraphPart();


    // ############################################################################
    // ############################################################################


    NodeGraphPart& operator=(const NodeGraphPart& p);


    bool operator==(const NodeGraphPart& p) const;


    bool operator!=(const NodeGraphPart& p) const;


    // ############################################################################
    // ############################################################################


    void populateNodes(const NodeGraphPart& s);


    template < typename T >
    void populateNodesFromProperty(const NodeProperty< T >& h);

    NodeId nextNodeId() const;


    virtual NodeId addNode();

    std::vector< NodeId > addNodes(Size n);


    virtual void addNodeWithId(const NodeId id);


    virtual void eraseNode(const NodeId id);

    bool existsNode(const NodeId id) const;

    bool exists(const NodeId id) const;

    bool emptyNodes() const;

    bool empty() const;

    virtual void clearNodes();

    virtual void clear();

    Size sizeNodes() const;

    Size size() const;

    NodeId bound() const;


    NodeSet asNodeSet() const;

    const NodeGraphPart& nodes() const;

    node_iterator_safe beginSafe() const;

    const node_iterator_safe& endSafe() const noexcept;

    node_iterator begin() const noexcept;

    const node_iterator& end() const noexcept;

    std::string toString() const;


    template < typename VAL >
    NodeProperty< VAL > nodesProperty(VAL (*f)(const NodeId&),
                                      Size size = 0) const;


    template < typename VAL >
    NodeProperty< VAL > nodesProperty(const VAL& a, Size size = 0) const;

    template < typename VAL >
    List< VAL > listMapNodes(VAL (*f)(const NodeId&)) const;


    private:
    friend class NodeGraphPartIterator;
    friend class NodeGraphPartIteratorSafe;


    friend class gum_tests::NodeGraphPartTestSuite;

    void __updateEndIteratorSafe();

    void __clearNodes();

    void __eraseHole(NodeId id);

    void __addHole(NodeId id);

    // ############################################################################
    // ############################################################################

    bool __inHoles(NodeId id) const;

    Size __sizeHoles() const;


    NodeSet* __holes;

    Size __holes_size;

    bool __holes_resize_policy;

    NodeGraphPartIteratorSafe __endIteratorSafe;

    NodeId __boundVal;
  };

  std::ostream& operator<<(std::ostream&, const NodeGraphPart&);

} /* namespace gum */

#ifndef GUM_NO_INLINE
#  include <agrum/tools/graphs/parts/nodeGraphPart_inl.h>
#endif   // GUM_NOINLINE

#include <agrum/tools/graphs/parts/nodeGraphPart_tpl.h>

#endif   // GUM_NODE_GRAPH_PART_H