graphChange.h

Go to the documentation of this file.

#ifndef GUM_LEARNING_GRAPH_CHANGE_H
#define GUM_LEARNING_GRAPH_CHANGE_H

#include <iostream>
#include <string>

#include <agrum/agrum.h>
#include <agrum/core/hashFunc.h>
#include <agrum/graphs/parts/nodeGraphPart.h>

namespace gum {

  namespace learning {

    enum GraphChangeType {
      ARC_ADDITION,
      ARC_DELETION,
      ARC_REVERSAL,
      EDGE_ADDITION,
      EDGE_DELETION
    };

    /* =========================================================================
     */
    /* ===                        GRAPH CHANGE CLASS                         ===
     */
    /* =========================================================================
     */
    class GraphChange {
      public:
      // ##########################################################################
      // ##########################################################################

      GraphChange(GraphChangeType type, NodeId node1, NodeId node2) noexcept;

      GraphChange(const GraphChange& from) noexcept;

      GraphChange(GraphChange&& from) noexcept;

      ~GraphChange() noexcept;


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

      GraphChange& operator=(const GraphChange& from) noexcept;

      GraphChange& operator=(GraphChange&& from) noexcept;

      bool operator==(const GraphChange& from) const noexcept;

      bool operator!=(const GraphChange& from) const noexcept;


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

      GraphChangeType type() const noexcept;

      NodeId node1() const noexcept;

      NodeId node2() const noexcept;

      virtual std::string toString() const;


      private:
      GraphChangeType __type;

      NodeId __node1;

      NodeId __node2;
    };

    /* =========================================================================
     */
    /* ===                        ARC ADDITION CLASS                         ===
     */
    /* =========================================================================
     */
    class ArcAddition : public GraphChange {
      public:
      // ##########################################################################
      // ##########################################################################

      ArcAddition(NodeId node1, NodeId node2) noexcept;

      ArcAddition(const ArcAddition& from) noexcept;

      ArcAddition(ArcAddition&& from) noexcept;

      ~ArcAddition() noexcept;


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

      ArcAddition& operator=(const ArcAddition& from) noexcept;

      ArcAddition& operator=(ArcAddition&& from) noexcept;

      bool operator==(const ArcAddition& from) const noexcept;

      bool operator!=(const ArcAddition& from) const noexcept;


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

      virtual std::string toString() const final;

    };

    /* =========================================================================
     */
    /* ===                        ARC DELETION CLASS                         ===
     */
    /* =========================================================================
     */
    class ArcDeletion : public GraphChange {
      public:
      // ##########################################################################
      // ##########################################################################

      ArcDeletion(NodeId node1, NodeId node2) noexcept;

      ArcDeletion(const ArcDeletion& from) noexcept;

      ArcDeletion(ArcDeletion&& from) noexcept;

      ~ArcDeletion() noexcept;


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

      ArcDeletion& operator=(const ArcDeletion& from) noexcept;

      ArcDeletion& operator=(ArcDeletion&& from) noexcept;

      bool operator==(const ArcDeletion& from) const noexcept;

      bool operator!=(const ArcDeletion& from) const noexcept;


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

      virtual std::string toString() const final;

    };

    /* =========================================================================
     */
    /* ===                        ARC REVERSAL CLASS                         ===
     */
    /* =========================================================================
     */
    class ArcReversal : public GraphChange {
      public:
      // ##########################################################################
      // ##########################################################################

      ArcReversal(NodeId node1, NodeId node2) noexcept;

      ArcReversal(const ArcReversal& from) noexcept;

      ArcReversal(ArcReversal&& from) noexcept;

      ~ArcReversal() noexcept;


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

      ArcReversal& operator=(const ArcReversal& from) noexcept;

      ArcReversal& operator=(ArcReversal&& from) noexcept;

      bool operator==(const ArcReversal& from) const noexcept;

      bool operator!=(const ArcReversal& from) const noexcept;


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

      virtual std::string toString() const final;

    };

    /* =========================================================================
     */
    /* ===                        EDGE ADDITION CLASS                        ===
     */
    /* =========================================================================
     */
    class EdgeAddition : public GraphChange {
      public:
      // ##########################################################################
      // ##########################################################################

      EdgeAddition(NodeId node1, NodeId node2) noexcept;

      EdgeAddition(const EdgeAddition& from) noexcept;

      EdgeAddition(EdgeAddition&& from) noexcept;

      ~EdgeAddition() noexcept;


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

      EdgeAddition& operator=(const EdgeAddition& from) noexcept;

      EdgeAddition& operator=(EdgeAddition&& from) noexcept;

      bool operator==(const EdgeAddition& from) const noexcept;

      bool operator!=(const EdgeAddition& from) const noexcept;


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

      virtual std::string toString() const final;

    };

    /* =========================================================================
     */
    /* ===                        EDGE DELETION CLASS                        ===
     */
    /* =========================================================================
     */
    class EdgeDeletion : public GraphChange {
      public:
      // ##########################################################################
      // ##########################################################################

      EdgeDeletion(NodeId node1, NodeId node2) noexcept;

      EdgeDeletion(const EdgeDeletion& from) noexcept;

      EdgeDeletion(EdgeDeletion&& from) noexcept;

      ~EdgeDeletion() noexcept;


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

      EdgeDeletion& operator=(const EdgeDeletion& from) noexcept;

      EdgeDeletion& operator=(EdgeDeletion&& from) noexcept;

      bool operator==(const EdgeDeletion& from) const noexcept;

      bool operator!=(const EdgeDeletion& from) const noexcept;


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

      virtual std::string toString() const final;

    };

    std::ostream& operator<<(std::ostream& stream, const GraphChange& change);

    std::ostream& operator<<(std::ostream& stream, const ArcAddition& change);

    std::ostream& operator<<(std::ostream& stream, const ArcDeletion& change);

    std::ostream& operator<<(std::ostream& stream, const ArcReversal& change);

    std::ostream& operator<<(std::ostream& stream, const EdgeAddition& change);

    std::ostream& operator<<(std::ostream& stream, const EdgeDeletion& change);

  } /* namespace learning */

  template <>
  class HashFunc< learning::GraphChange >
      : public HashFuncBase< learning::GraphChange > {
    public:
    static Size castToSize(const learning::GraphChange& key);

    virtual Size operator()(const learning::GraphChange& key) const override final;
  };

  template <>
  class HashFunc< learning::ArcAddition >
      : public HashFuncBase< learning::ArcAddition > {
    public:
    static Size castToSize(const learning::ArcAddition& key);

    virtual Size operator()(const learning::ArcAddition& key) const override final;
  };

  template <>
  class HashFunc< learning::ArcDeletion >
      : public HashFuncBase< learning::ArcDeletion > {
    public:
    static Size castToSize(const learning::ArcDeletion& key);

    virtual Size operator()(const learning::ArcDeletion& key) const override final;
  };

  template <>
  class HashFunc< learning::ArcReversal >
      : public HashFuncBase< learning::ArcReversal > {
    public:
    static Size castToSize(const learning::ArcReversal& key);

    virtual Size operator()(const learning::ArcReversal& key) const override final;
  };

  template <>
  class HashFunc< learning::EdgeAddition >
      : public HashFuncBase< learning::EdgeAddition > {
    static Size castToSize(const learning::EdgeAddition& key);

    virtual Size
       operator()(const learning::EdgeAddition& key) const override final;
  };

  template <>
  class HashFunc< learning::EdgeDeletion >
      : public HashFuncBase< learning::EdgeDeletion > {
    public:
    static Size castToSize(const learning::EdgeDeletion& key);

    virtual Size
       operator()(const learning::EdgeDeletion& key) const override final;
  };

} /* namespace gum */

#ifndef GUM_NO_INLINE
#  include <agrum/learning/structureUtils/graphChange_inl.h>
#endif   // GUM_NOINLINE

#endif /* GUM_LEARNING_GRAPH_CHANGE_H */