graphChange.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Christophe GONZALES and Pierre-Henri WUILLEMIN  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#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 */