set.h

Go to the documentation of this file.

/****************************************************************************
 *   This file is part of the aGrUM/pyAgrum library.                        *
 *                                                                          *
 *   Copyright (c) 2005-2026 by                                             *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *                                                                          *
 *   The aGrUM/pyAgrum library is free software; you can redistribute it    *
 *   and/or modify it under the terms of either :                           *
 *                                                                          *
 *    - the GNU Lesser General Public License as published by               *
 *      the Free Software Foundation, either version 3 of the License,      *
 *      or (at your option) any later version,                              *
 *    - the MIT license (MIT),                                              *
 *    - or both in dual license, as here.                                   *
 *                                                                          *
 *   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    *
 *                                                                          *
 *   This aGrUM/pyAgrum library is distributed in the hope that it will be  *
 *   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          *
 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
 *   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   *
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  *
 *   OTHER DEALINGS IN THE SOFTWARE.                                        *
 *                                                                          *
 *   See LICENCES for more details.                                         *
 *                                                                          *
 *   SPDX-FileCopyrightText: Copyright 2005-2026                            *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      *
 *                                                                          *
 *   Contact  : info_at_agrum_dot_org                                       *
 *   homepage : http://agrum.gitlab.io                                      *
 *   gitlab   : https://gitlab.com/agrumery/agrum                           *
 *                                                                          *
 ****************************************************************************/
 

#ifndef GUM_SET_H
#define GUM_SET_H
 
#include <string>
 
#include <agrum/base/core/debug.h>
#include <agrum/base/core/hashTable.h>
#include <agrum/base/core/list.h>
 
#include <initializer_list>
 
namespace gum {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
  template < typename Key >
  class SetIteratorSafe;
  template < typename Key >
  class SetIterator;
  template < typename Key >
  class Set;
 
  template < typename Key >
  using SetConstIterator = SetIterator< Key >;
  template < typename Key >
  using SetConstIteratorSafe = SetIteratorSafe< Key >;
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
  // ===========================================================================
  // ===                               GUM_SET                               ===
  // ===========================================================================

  template < typename Key >
  class Set {
    public:
    using value_type          = Key;
    using reference           = Key&;
    using const_reference     = const Key&;
    using pointer             = Key*;
    using const_pointer       = const Key*;
    using size_type           = std::size_t;
    using difference_type     = std::ptrdiff_t;
    using iterator            = SetIterator< Key >;
    using const_iterator      = SetIterator< Key >;
    using iterator_safe       = SetIteratorSafe< Key >;
    using const_iterator_safe = SetIteratorSafe< Key >;
 
    // ============================================================================
    // ============================================================================

    explicit Set(Size capacity = HashTableConst::default_size, bool resize_policy = true);

    Set(std::initializer_list< Key > list);

    Set(const Set< Key >& aHT);

    Set(Set< Key >&& aHT) noexcept;

    ~Set();

    // ============================================================================
    // ============================================================================

    Set< Key >& operator=(const Set< Key >& from);

    Set< Key >& operator=(Set< Key >&& from) noexcept;

    bool operator==(const Set< Key >& s2) const;

    const Set< Key >& operator*=(const Set< Key >& s2);

    Set< Key > operator*(const Set< Key >& s2) const;

    const Set< Key >& operator+=(const Set< Key >& s2);

    Set< Key > operator+(const Set< Key >& s2) const;
 

    Set< Key > operator-(const Set< Key >& s2) const;

    Set< Key >& operator<<(const Key& k);

    Set< Key >& operator<<(Key&& k);

    Set< Key >& operator>>(const Key& k);

    // ============================================================================
    // ============================================================================

    void insert(const Key& k);

    void insert(Key&& k);

    template < typename... Args >
    void emplace(Args&&... args);

    void erase(const Key& k);

    Key popFirst();

    void erase(const iterator_safe& k);

    void clear();

    Size size() const noexcept;

    bool contains(const Key& k) const;

    bool isStrictSubsetOf(const Set< Key >& s) const;

    bool isStrictSupersetOf(const Set< Key >& s) const;

    bool isSubsetOrEqual(const Set< Key >& s) const;

    bool isSupersetOrEqual(const Set< Key >& s) const;

    bool exists(const Key& k) const;

    bool empty() const noexcept;

    std::string toString() const;

    // ============================================================================
    // ============================================================================

    iterator_safe beginSafe() const;

    const_iterator_safe cbeginSafe() const;

    static const iterator_safe& endSafe() noexcept;

    static const const_iterator_safe& cendSafe() noexcept;

    iterator begin() const;

    const_iterator cbegin() const;

    static const iterator& end() noexcept;

    static const const_iterator& cend() noexcept;

 
    // ============================================================================
    // ============================================================================

    Size capacity() const;

    void resize(Size new_capacity);

    void setResizePolicy(const bool new_policy);

    bool resizePolicy() const;

    // ============================================================================
    // ============================================================================

    template < typename NewKey >
    HashTable< Key, NewKey > hashMap(NewKey (*f)(const Key&), Size capacity = 0) const;

    template < typename NewKey >
    HashTable< Key, NewKey > hashMap(const NewKey& val, Size size = 0) const;

    template < typename NewKey >
    List< NewKey > listMap(NewKey (*f)(const Key&)) const;

 
    private:
    friend class SetIterator< Key >;
    friend class SetIteratorSafe< Key >;

    HashTable< Key, bool > _inside_;

    explicit Set(const HashTable< Key, bool >& h);
  };
 
  // ===========================================================================
  // ===                          SAFE SET ITERATORS                         ===
  // ===========================================================================

  template < typename Key >
  class SetIteratorSafe {
    public:
    using iterator_category = std::forward_iterator_tag;
    using value_type        = Key;
    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;


    enum class Position : unsigned char { BEGIN, END };
 
    // ============================================================================
    // ============================================================================

    explicit SetIteratorSafe();
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#  ifndef SWIG
    // constructor for the static endSafe iterator
    // only set.cpp should use this constructor
    // hidden from SWIG: it does not understand consteval and mistakes this
    // overload for a redefinition of the default constructor above (warning 302)
    explicit consteval SetIteratorSafe(StaticInitializer init) noexcept : _ht_iter_(init) {}
#  endif   // SWIG
#endif     // DOXYGEN_SHOULD_SKIP_THIS

    explicit SetIteratorSafe(const Set< Key >& from, Position pos = Position::BEGIN);

    SetIteratorSafe(const SetIteratorSafe< Key >& from);

    explicit SetIteratorSafe(const SetIterator< Key >& iter);

    SetIteratorSafe(SetIteratorSafe< Key >&& from) noexcept;

    ~SetIteratorSafe() noexcept;

    // ============================================================================
    // ============================================================================

    SetIteratorSafe< Key >& operator=(const SetIteratorSafe< Key >& from);

    SetIteratorSafe< Key >& operator=(const SetIterator< Key >& iter);

    SetIteratorSafe< Key >& operator=(SetIteratorSafe< Key >&& from) noexcept;

    SetIteratorSafe< Key >& operator++() noexcept;

    SetIteratorSafe< Key >& operator+=(Size i) noexcept;

    SetIteratorSafe< Key > operator+(Size i) const;

    bool operator==(const SetIteratorSafe< Key >& from) const noexcept;

    const Key& operator*() const;

    const Key* operator->() const;

    // ============================================================================
    // ============================================================================

    void clear() noexcept;

 
    private:
    friend class Set< Key >;

    HashTableConstIteratorSafe< Key, bool > _ht_iter_;
  };
 
  // ===========================================================================
  // ===                         UNSAFE SET ITERATORS                        ===
  // ===========================================================================

  template < typename Key >
  class SetIterator {
    public:
    using iterator_category = std::forward_iterator_tag;
    using value_type        = Key;
    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;


    enum class Position : unsigned char { BEGIN, END };
 
    // ============================================================================
    // ============================================================================

    explicit SetIterator() noexcept;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#  ifndef SWIG
    // constructor for the static end iterator
    // only set.cpp should use this constructor
    // hidden from SWIG: it does not understand consteval and mistakes this
    // overload for a redefinition of the default constructor above (warning 302)
    explicit consteval SetIterator(StaticInitializer init) noexcept : _ht_iter_(init) {}
#  endif   // SWIG
#endif     // DOXYGEN_SHOULD_SKIP_THIS

    explicit SetIterator(const Set< Key >& from, Position pos = Position::BEGIN);

    SetIterator(const SetIterator< Key >& iter) noexcept;

    SetIterator(SetIterator< Key >&& from) noexcept;

    ~SetIterator() noexcept;

    // ============================================================================
    // ============================================================================

    SetIterator< Key >& operator=(const SetIterator< Key >& iter) noexcept;

    SetIterator< Key >& operator=(SetIterator< Key >&& from) noexcept;

    SetIterator< Key >& operator++() noexcept;

    SetIterator< Key >& operator+=(Size nb) noexcept;

    SetIterator< Key > operator+(Size nb) const noexcept;

    bool operator==(const SetIterator< Key >& iter) const noexcept;

    const Key& operator*() const;

    const Key* operator->() const;

    // ============================================================================
    // ============================================================================

    void clear() noexcept;

 
    private:
    friend class Set< Key >;
    friend class SetIteratorSafe< Key >;

    HashTableConstIterator< Key, bool > _ht_iter_;
  };

  template < typename Key >
  std::ostream& operator<<(std::ostream&, const Set< Key >&);

  template < typename T >
  class HashFunc< Set< T > >: public HashFuncBase< Set< T > > {
    public:
    static Size castToSize(const Set< T >& key);

    Size operator()(const Set< T >& key) const final;
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // _static_Set_end_ is a 'constant' iterator initialized at compile time
  // that represents the end iterators for all sets (whatever their
  // type). This global variable avoids creating the same iterators within every
  // Set instance (this would be quite inefficient as end is precisely
  // identical for all sets). The same hold for safe end iterators.
  // The type of _Set_end_ is a pointer to void because C++ allows
  // pointers to void to be cast into pointers to other types (and conversely).
  // This avoids the painful strict-aliasing rule warning
  extern const SetIterator< int >     _static_Set_end_;
  extern const SetIteratorSafe< int > _static_Set_end_safe_;
 
  inline constexpr const void* const _Set_end_      = &_static_Set_end_;
  inline constexpr const void* const _Set_end_safe_ = &_static_Set_end_safe_;
#endif   // DOXYGEN_SHOULD_SKIP_THIS
 
} /* namespace gum */
 
 
#if !defined(GUM_NO_EXTERN_TEMPLATE_CLASS) && !defined(SWIG)
extern template class gum::Set< int >;
extern template class gum::Set< long >;
extern template class gum::Set< unsigned int >;
extern template class gum::Set< unsigned long >;
extern template class gum::Set< double >;
extern template class gum::Set< std::string >;
#endif
 
 
// always include the implementation of the templates
#include <agrum/base/core/set_tpl.h>
 
#endif   // GUM_SET_H