idCondSet.h

Go to the documentation of this file.

#ifndef GUM_LEARNING_ID_SET_H
#define GUM_LEARNING_ID_SET_H

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

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

namespace gum {

  namespace learning {


    template < template < typename > class ALLOC >
    class IdCondSet;


    template < template < typename > class ALLOC = std::allocator >
    class IdCondSetIterator {
      public:
      using iterator_category = std::forward_iterator_tag;
      using value_type = NodeId;
      using reference = NodeId&;
      using const_reference = const NodeId&;
      using pointer = NodeId*;
      using const_pointer = const NodeId*;
      using difference_type = std::ptrdiff_t;


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


      IdCondSetIterator();


      IdCondSetIterator(const IdCondSet< ALLOC >& idset);

      IdCondSetIterator(const IdCondSetIterator< ALLOC >& from);

      IdCondSetIterator(IdCondSetIterator< ALLOC >&& from);

      virtual ~IdCondSetIterator();



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

      IdCondSetIterator< ALLOC >& operator=(const IdCondSetIterator< ALLOC >& from);

      IdCondSetIterator< ALLOC >& operator=(IdCondSetIterator< ALLOC >&& from);

      NodeId operator*() const;

      bool operator!=(const IdCondSetIterator< ALLOC >& from) const;

      bool operator==(const IdCondSetIterator< ALLOC >& from) const;

      IdCondSetIterator< ALLOC >& operator++();

      IdCondSetIterator< ALLOC >& operator+=(const std::size_t i);

      IdCondSetIterator< ALLOC > operator+(const std::size_t i);



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

      std::size_t pos() const;



#ifndef DOXYGEN_SHOULD_SKIP_THIS

      private:
      const Sequence< NodeId, ALLOC< NodeId > >* __seq{nullptr};

      std::size_t __index{std::size_t(0)};


      void __gotoEnd();

      friend class IdCondSet< ALLOC >;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };


    template < template < typename > class ALLOC = std::allocator >
    class IdCondSet: private ALLOC< NodeId > {
      public:
      using allocator_type = ALLOC< NodeId >;

      using iterator = IdCondSetIterator< ALLOC >;
      using const_iterator = IdCondSetIterator< ALLOC >;
      using iterator_safe = IdCondSetIterator< ALLOC >;
      using const_iterator_safe = IdCondSetIterator< ALLOC >;

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

      IdCondSet(const allocator_type& alloc = allocator_type());


      IdCondSet(const std::vector< NodeId, ALLOC< NodeId > >& ids,
            const bool                                    rhs_ids,
            const bool                                    ordered_ids,
            const allocator_type& alloc = allocator_type());


      IdCondSet(NodeId                                        var1,
            const std::vector< NodeId, ALLOC< NodeId > >& rhs_ids,
            const bool                                    ordered_rhs_ids = false,
            const allocator_type& alloc = allocator_type());


      IdCondSet(NodeId                                        var1,
            NodeId                                        var2,
            const std::vector< NodeId, ALLOC< NodeId > >& rhs_ids,
            const bool                                    ordered_lhs_vars,
            const bool                                    ordered_rhs_ids = false,
            const allocator_type& alloc = allocator_type());


      IdCondSet(NodeId                                        var1,
            NodeId                                        var2,
            NodeId                                        var3,
            const std::vector< NodeId, ALLOC< NodeId > >& rhs_ids,
            const bool                                    ordered_lhs_vars,
            const bool                                    ordered_rhs_ids = false,
            const allocator_type& alloc = allocator_type());

      IdCondSet(const IdCondSet< ALLOC >& from);

      IdCondSet(const IdCondSet< ALLOC >& from, const allocator_type& alloc);

      IdCondSet(IdCondSet< ALLOC >&& from);

      IdCondSet(IdCondSet< ALLOC >&& from, const allocator_type& alloc);

      virtual IdCondSet< ALLOC >* clone() const;

      virtual IdCondSet< ALLOC >* clone(const allocator_type& alloc) const;

      virtual ~IdCondSet();



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

      IdCondSet< ALLOC >& operator=(const IdCondSet< ALLOC >& from);

      IdCondSet< ALLOC >& operator=(IdCondSet< ALLOC >&& from);

      NodeId operator[](const std::size_t index) const;

      bool operator==(const IdCondSet< ALLOC >& from) const;

      bool operator!=(const IdCondSet< ALLOC >& from) const;



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

      iterator_safe beginSafe() const;

      const iterator_safe& endSafe() const;

      iterator begin() const;

      const iterator& end() const;



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

      const Sequence< NodeId, ALLOC< NodeId > >& ids() const;

      IdCondSet< ALLOC > conditionalIdCondSet() const;

      std::size_t nbLHSIds() const;

      std::size_t nbRHSIds() const;

      bool contains(const IdCondSet< ALLOC >& set) const;

      void clear();

      std::size_t size() const;


      std::size_t pos(const NodeId id) const;

      bool exists(const NodeId id) const;


      void erase(const NodeId id);

      bool hasConditioningSet() const;

      bool empty() const;

      std::string toString() const;

      allocator_type getAllocator() const;



#ifndef DOXYGEN_SHOULD_SKIP_THIS

      private:
      Sequence< NodeId, ALLOC< NodeId > > __ids;

      std::size_t __nb_lhs_ids{std::size_t(0)};

      IdCondSetIterator< ALLOC > __end_safe;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };


    template < template < typename > class ALLOC >
    std::ostream& operator<<(std::ostream& stream, const IdCondSet< ALLOC >& idset);

  } /* namespace learning */


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

    virtual Size
       operator()(const learning::IdCondSet< ALLOC >& key) const override final;
  };


} /* namespace gum */


// always include the template implementation
#include <agrum/BN/learning/scores_and_tests/idCondSet_tpl.h>

#endif /* GUM_LEARNING_ID_SET_H */