d2/d0a/bijection_8h_source.html

/****************************************************************************

 *   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_BIJECTION_H

#define GUM_BIJECTION_H


#include <iostream>

#include <sstream>

#include <string>


#include <agrum/base/core/hashTable.h>


#include <initializer_list>

#include <type_traits>


namespace gum {


#ifndef DOXYGEN_SHOULD_SKIP_THIS


  template < typename T1, typename T2 >

  class BijectionIteratorSafe;

  template < typename T1, typename T2 >

  class BijectionIterator;

  template < typename T1, typename T2, bool >

  class BijectionImplementation;

  template < typename T1, typename T2 >

  class Bijection;


#endif /* DOXYGEN_SHOULD_SKIP_THIS */


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

  // ===                NON SCALAR BIJECTION IMPLEMENTATION                  ===

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


  template < typename T1, typename T2, bool Gen >


  class BijectionImplementation {

    public:

    using type1_type            = T1;

    using type1_reference       = T1&;

    using type1_const_reference = const T1&;

    using type1_pointer         = T1*;

    using type1_const_pointer   = const T1*;

    using type2_type            = T2;

    using type2_reference       = T2&;

    using type2_const_reference = const T2&;

    using type2_pointer         = T2*;

    using type2_const_pointer   = const T2*;

    using size_type             = std::size_t;

    using difference_type       = std::ptrdiff_t;

    using iterator              = BijectionIterator< T1, T2 >;

    using const_iterator        = BijectionIterator< T1, T2 >;

    using iterator_safe         = BijectionIteratorSafe< T1, T2 >;

    using const_iterator_safe   = BijectionIteratorSafe< T1, T2 >;


    private:

    BijectionImplementation(Size size, bool resize_policy);


    BijectionImplementation(std::initializer_list< std::pair< T1, T2 > > list);


    BijectionImplementation(const BijectionImplementation< T1, T2, Gen >& toCopy);


    BijectionImplementation(BijectionImplementation< T1, T2, Gen >&& from) noexcept;


    public:

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

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


    ~BijectionImplementation();


    private:

    BijectionImplementation< T1, T2, Gen >&

        operator=(const BijectionImplementation< T1, T2, Gen >& toCopy);


    BijectionImplementation< T1, T2, Gen >&

        operator=(BijectionImplementation< T1, T2, Gen >&& toCopy);


    public:

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

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


    iterator begin() const;


    const_iterator cbegin() const;


    const iterator& end() const noexcept;


    const const_iterator& cend() const noexcept;


    iterator_safe beginSafe() const;


    const_iterator_safe cbeginSafe() const;


    const iterator_safe& endSafe() const noexcept;


    const const_iterator_safe& cendSafe() const noexcept;


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

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


    const T1& first(const T2& second) const;


    const T1& firstWithDefault(const T2& second, const T1& default_val) const;


    const T2& second(const T1& first) const;


    template < typename K >

      requires(std::same_as< T1, std::string > && std::convertible_to< K, std::string_view >

               && !std::same_as< std::decay_t< K >, std::string >)

    const T2& second(const K& first) const;


    const T2& secondWithDefault(const T1& second, const T2& default_val) const;


    bool existsFirst(const T1& first) const;


    template < typename K >

      requires(std::same_as< T1, std::string > && std::convertible_to< K, std::string_view >

               && !std::same_as< std::decay_t< K >, std::string >)

    bool existsFirst(const K& first) const;


    bool existsSecond(const T2& second) const;


    optional_ref< const T1 > tryFirst(const T2& second) const;


    optional_ref< const T2 > trySecond(const T1& first) const;


    template < typename K >

      requires(std::same_as< T1, std::string > && std::convertible_to< K, std::string_view >

               && !std::same_as< std::decay_t< K >, std::string >)

    optional_ref< const T2 > trySecond(const K& first) const;


    void insert(const T1& first, const T2& second);


    void insert(T1&& first, T2&& second);


    template < typename... Args >

    void emplace(Args&&... args);


    void clear();


    bool empty() const noexcept;


    Size size() const noexcept;


    void eraseFirst(const T1& first);


    void eraseSecond(const T2& second);


    std::string toString() const;


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

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


    Size capacity() const noexcept;


    void resize(Size new_size);


    void setResizePolicy(const bool new_policy) noexcept;


    bool resizePolicy() const noexcept;


    private:

    using HashTable12 = HashTable< T1, T2* >;

    using HashTable21 = HashTable< T2, T1* >;


    friend class BijectionIteratorSafe< T1, T2 >;

    friend class BijectionIterator< T1, T2 >;

    friend class Bijection< T1, T2 >;

    template < typename TT1, typename TT2, bool >

    friend class BijectionImplementation;


    // Below, we create the two gum::HashTable used by the gum::Bijection. Note

    // that the values of these gum::HashTable are pointers. This enables to

    // create only once objects (T1,T2). When using gum::Bijection with large

    // size objects, this feature is of particular interest.


    HashTable12 _firstToSecond_;


    HashTable21 _secondToFirst_;


    void _copy_(const HashTable< T1, T2* >& source);


    typename HashTable12::value_type* _insert_(const T1& first, const T2& second);


    typename HashTable12::value_type* _insert_(T1&& first, T2&& second);

  };


#ifndef DOXYGEN_SHOULD_SKIP_THIS


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

  // ===                  SCALAR BIJECTION IMPLEMENTATION                    ===

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


  template < typename T1, typename T2 >

  class BijectionImplementation< T1, T2, true > {

    public:

    using type1_type            = T1;

    using type1_reference       = T1&;

    using type1_const_reference = const T1&;

    using type1_pointer         = T1*;

    using type1_const_pointer   = const T1*;

    using type2_type            = T2;

    using type2_reference       = T2&;

    using type2_const_reference = const T2&;

    using type2_pointer         = T2*;

    using type2_const_pointer   = const T2*;

    using size_type             = std::size_t;

    using difference_type       = std::ptrdiff_t;

    using iterator              = BijectionIterator< T1, T2 >;

    using const_iterator        = BijectionIterator< T1, T2 >;

    using iterator_safe         = BijectionIteratorSafe< T1, T2 >;

    using const_iterator_safe   = BijectionIteratorSafe< T1, T2 >;


    private:

    BijectionImplementation(Size size, bool resize_policy);


    BijectionImplementation(std::initializer_list< std::pair< T1, T2 > > list);


    BijectionImplementation(const BijectionImplementation< T1, T2, true >& toCopy);


    BijectionImplementation(BijectionImplementation< T1, T2, true >&& from) noexcept;


    public:

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

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


    ~BijectionImplementation();


    private:

    BijectionImplementation< T1, T2, true >&

        operator=(const BijectionImplementation< T1, T2, true >& toCopy);


    BijectionImplementation< T1, T2, true >&

        operator=(BijectionImplementation< T1, T2, true >&& from);


    public:

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

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


    iterator begin() const;


    const_iterator cbegin() const;


    const iterator& end() const noexcept;


    const const_iterator& cend() const noexcept;


    iterator_safe beginSafe() const;


    const_iterator_safe cbeginSafe() const;


    const iterator_safe& endSafe() const noexcept;


    const const_iterator_safe& cendSafe() const noexcept;


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

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


    const T1& first(T2 second) const;


    const T1& firstWithDefault(T2 second, T1 default_val) const;


    const T2& second(T1 first) const;


    const T2& secondWithDefault(T1 first, T2 default_val) const;


    bool existsFirst(T1 first) const;


    bool existsSecond(T2 second) const;


    optional_ref< const T1 > tryFirst(T2 second) const;


    optional_ref< const T2 > trySecond(T1 first) const;


    void insert(T1 first, T2 second);


    template < typename... Args >

    void emplace(Args&&... args);


    void clear();


    bool empty() const noexcept;


    Size size() const noexcept;


    void eraseFirst(T1 first);


    void eraseSecond(T2 second);


    std::string toString() const;


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

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


    Size capacity() const noexcept;


    void resize(Size new_size);


    void setResizePolicy(const bool new_policy) noexcept;


    bool resizePolicy() const noexcept;


    private:

    using HashTable12 = HashTable< T1, T2 >;

    using HashTable21 = HashTable< T2, T1 >;


    friend class BijectionIteratorSafe< T1, T2 >;

    friend class BijectionIterator< T1, T2 >;

    friend class Bijection< T1, T2 >;

    template < typename TT1, typename TT2, bool >

    friend class BijectionImplementation;


    // Below, we create the two gum::HashTable used by the gum::Bijection. Note

    // that the values of these gum::HashTable are pointers. This enables to

    // create only once objects (T1,T2). When using gum::Bijection with large

    // size objects, this feature is of particular interest.


    HashTable12 _firstToSecond_;


    HashTable21 _secondToFirst_;


    void _copy_(const HashTable< T1, T2 >& f2s);


    void _insert_(const T1 first, const T2 second);

  };


#endif /* DOXYGEN_SHOULD_SKIP_THIS */


  template < bool gen >


  struct BijectionIteratorGet {

    template < typename T >

    static const T& op_second(const T* x);

  };


  template <>


  struct BijectionIteratorGet< true > {

    template < typename T >

    static const T& op_second(const T& x);

  };


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

  // ===                      BIJECTION SAFE ITERATORS                       ===

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


  template < typename T1, typename T2 >


  class BijectionIteratorSafe {

    template < typename TT1, typename TT2, bool >

    friend class BijectionImplementation;


    public:

    using iterator_category     = std::forward_iterator_tag;

    using type1_type            = T1;

    using type1_reference       = T1&;

    using type1_const_reference = const T1&;

    using type1_pointer         = T1*;

    using type1_const_pointer   = const T1*;

    using type2_type            = T2;

    using type2_reference       = T2&;

    using type2_const_reference = const T2&;

    using type2_pointer         = T2*;

    using type2_const_pointer   = const T2*;

    using difference_type       = std::ptrdiff_t;


    private:

    using Getter

        = BijectionIteratorGet< std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >;


    template < bool Gen >

    BijectionIteratorSafe(const BijectionImplementation< T1, T2, Gen >& bijection);


    public:

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

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


    explicit BijectionIteratorSafe() noexcept;


#ifndef DOXYGEN_SHOULD_SKIP_THIS

    // constructor for the static endSafe iterator

    // only bijection.cpp should use this constructor

    explicit consteval BijectionIteratorSafe(StaticInitializer init) noexcept : _iter_(init) {}

#endif   // DOXYGEN_SHOULD_SKIP_THIS


    BijectionIteratorSafe(const Bijection< T1, T2 >& bijection);


    BijectionIteratorSafe(const BijectionIteratorSafe< T1, T2 >& from);


    BijectionIteratorSafe(BijectionIteratorSafe< T1, T2 >&& from) noexcept;


    ~BijectionIteratorSafe() noexcept;


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

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


    BijectionIteratorSafe< T1, T2 >& operator=(const BijectionIteratorSafe< T1, T2 >& toCopy);


    BijectionIteratorSafe< T1, T2 >& operator=(BijectionIteratorSafe< T1, T2 >&& toMove) noexcept;


    BijectionIteratorSafe< T1, T2 >& operator++() noexcept;


    BijectionIteratorSafe< T1, T2 >& operator+=(Size nb) noexcept;


    BijectionIteratorSafe< T1, T2 > operator+(Size nb) noexcept;


    bool operator!=(const BijectionIteratorSafe< T1, T2 >& toCompare) const noexcept;


    bool operator==(const BijectionIteratorSafe< T1, T2 >& toCompare) const noexcept;


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

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


    const T1& first() const;


    const T2& second() const;


    private:

    using HashTable12 =

        typename std::conditional< std::is_scalar< T1 >::value && std::is_scalar< T2 >::value,

                                   HashTable< T1, T2 >,

                                   HashTable< T1, T2* > >::type;


    using HashIter = typename HashTable12::const_iterator_safe;


    HashIter _iter_;

  };


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

  // ===                     BIJECTION UNSAFE ITERATORS                      ===

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

  template < typename T1, typename T2 >


  class BijectionIterator {

    template < typename TT1, typename TT2, bool >

    friend class BijectionImplementation;


    public:

    using iterator_category     = std::forward_iterator_tag;

    using type1_type            = T1;

    using type1_reference       = T1&;

    using type1_const_reference = const T1&;

    using type1_pointer         = T1*;

    using type1_const_pointer   = const T1*;

    using type2_type            = T2;

    using type2_reference       = T2&;

    using type2_const_reference = const T2&;

    using type2_pointer         = T2*;

    using type2_const_pointer   = const T2*;

    using difference_type       = std::ptrdiff_t;


    private:

    using Getter

        = BijectionIteratorGet< std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >;


    template < bool Gen >

    BijectionIterator(const BijectionImplementation< T1, T2, Gen >& bijection);


    public:

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

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


    explicit BijectionIterator() noexcept;


#ifndef DOXYGEN_SHOULD_SKIP_THIS

    // constructor for the static end iterator

    // only bijection.cpp should use this constructor

    explicit consteval BijectionIterator(StaticInitializer init) noexcept : _iter_(init) {}

#endif   // DOXYGEN_SHOULD_SKIP_THIS


    BijectionIterator(const Bijection< T1, T2 >& bijection);


    BijectionIterator(const BijectionIterator< T1, T2 >& from);


    BijectionIterator(BijectionIterator< T1, T2 >&& from) noexcept;


    ~BijectionIterator() noexcept;


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

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


    BijectionIterator< T1, T2 >& operator=(const BijectionIterator< T1, T2 >& toCopy);


    BijectionIterator< T1, T2 >& operator=(BijectionIterator< T1, T2 >&& toMove) noexcept;


    BijectionIterator< T1, T2 >& operator++() noexcept;


    BijectionIterator< T1, T2 >& operator+=(Size nb) noexcept;


    BijectionIterator< T1, T2 > operator+(Size nb) noexcept;


    bool operator!=(const BijectionIterator< T1, T2 >& toCompare) const noexcept;


    bool operator==(const BijectionIterator< T1, T2 >& toCompare) const noexcept;


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

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


    const T1& first() const;


    const T2& second() const;


    private:

    using HashTable12 =

        typename std::conditional< std::is_scalar< T1 >::value && std::is_scalar< T2 >::value,

                                   HashTable< T1, T2 >,

                                   HashTable< T1, T2* > >::type;

    using HashIter = typename HashTable12::const_iterator;


    HashIter _iter_;

  };


  template < typename T1, typename T2 >


  class Bijection:

      public BijectionImplementation< T1,

                                      T2,

                                      std::is_scalar< T1 >::value && std::is_scalar< T2 >::value > {

    public:

    using type1_type            = T1;

    using type1_reference       = T1&;

    using type1_const_reference = const T1&;

    using type1_pointer         = T1*;

    using type1_const_pointer   = const T1*;

    using type2_type            = T2;

    using type2_reference       = T2&;

    using type2_const_reference = const T2&;

    using type2_pointer         = T2*;

    using type2_const_pointer   = const T2*;

    using size_type             = std::size_t;

    using difference_type       = std::ptrdiff_t;

    using iterator              = BijectionIterator< T1, T2 >;

    using const_iterator        = BijectionIterator< T1, T2 >;

    using iterator_safe         = BijectionIteratorSafe< T1, T2 >;

    using const_iterator_safe   = BijectionIteratorSafe< T1, T2 >;


    using Implementation

        = BijectionImplementation< T1,

                                   T2,

                                   std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >;


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

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


    Bijection(Size size          = HashTableConst::default_size,

              bool resize_policy = HashTableConst::default_resize_policy);


    Bijection(std::initializer_list< std::pair< T1, T2 > > list);


    Bijection(const Bijection< T1, T2 >& toCopy);


    Bijection(Bijection< T1, T2 >&& from) noexcept;


    ~Bijection();


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

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


    Bijection< T1, T2 >& operator=(const Bijection< T1, T2 >& toCopy);


    Bijection< T1, T2 >& operator=(Bijection< T1, T2 >&& bij);


  };


#ifndef DOXYGEN_SHOULD_SKIP_THIS

  // _static_Bijection_end_ is a 'constant' iterator initialized at compile time

  // that represents the end iterators for all bijections (whatever their

  // type). This global variable avoids creating the same iterators within every

  // Bijection instance (this would be quite inefficient as end is precisely

  // identical for all bijections). The same hold for safe end iterators.

  // The type of _Bijection_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 BijectionIterator< int, int >     _static_Bijection_end_;

  extern const BijectionIteratorSafe< int, int > _static_Bijection_end_safe_;


  inline constexpr void* const _Bijection_end_      = (void* const)&_static_Bijection_end_;

  inline constexpr void* const _Bijection_end_safe_ = (void* const)&_static_Bijection_end_safe_;

#endif   // DOXYGEN_SHOULD_SKIP_THIS


  template < typename T1, typename T2 >

  std::ostream& operator<<(std::ostream&, const Bijection< T1, T2 >& bijection);


} /* namespace gum */


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS

extern template class gum::Bijection< int, int >;

extern template class gum::Bijection< std::string, std::string >;

#endif


// always include the template implementations

#include <agrum/base/core/bijection_tpl.h>


#endif /* GUM_BIJECTION_H */

bijection_tpl.h
Class providing generic double hash tables.

friend

gum::BijectionImplementation
A non scalar implementation of a Bijection.
Definition bijection.h:104

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::emplace
void emplace(Args &&... args)

gum::BijectionImplementation::iterator_safe
BijectionIteratorSafe< T1, T2 > iterator_safe
types for STL compliance
Definition bijection.h:122

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::setResizePolicy
void setResizePolicy(const bool new_policy) noexcept

gum::BijectionImplementation::BijectionImplementation
BijectionImplementation(const BijectionImplementation< T1, T2, Gen > &toCopy)
Copy constructor.
Definition bijection_tpl.h:112

gum::BijectionImplementation::type1_type
T1 type1_type
types for STL compliance
Definition bijection.h:108

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::trySecond
optional_ref< const T2 > trySecond(const T1 &first) const

gum::BijectionImplementation::size_type
std::size_t size_type
types for STL compliance
Definition bijection.h:118

gum::BijectionImplementation::type2_const_pointer
const T2 * type2_const_pointer
types for STL compliance
Definition bijection.h:117

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::resizePolicy
bool resizePolicy() const noexcept

gum::BijectionImplementation::const_iterator_safe
BijectionIteratorSafe< T1, T2 > const_iterator_safe
types for STL compliance
Definition bijection.h:123

gum::BijectionImplementation::end
const iterator & end() const noexcept
Returns the unsafe iterator at the end of the gum::Bijection.
Definition bijection_tpl.h:195

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_firstToSecond_
HashTable12 _firstToSecond_
Definition bijection.h:616

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::endSafe
const iterator_safe & endSafe() const noexcept

gum::BijectionImplementation::HashTable21
HashTable< T2, T1 * > HashTable21
Alias for more readable code.
Definition bijection.h:598

gum::BijectionImplementation::difference_type
std::ptrdiff_t difference_type
types for STL compliance
Definition bijection.h:119

gum::BijectionImplementation::const_iterator
BijectionIterator< T1, T2 > const_iterator
types for STL compliance
Definition bijection.h:121

gum::BijectionImplementation::cbegin
const_iterator cbegin() const
Returns the constant unsafe iterator at the beginning of the gum::Bjection.
Definition bijection_tpl.h:188

gum::BijectionImplementation::type2_pointer
T2 * type2_pointer
types for STL compliance
Definition bijection.h:116

gum::BijectionImplementation::type1_const_pointer
const T1 * type1_const_pointer
types for STL compliance
Definition bijection.h:112

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_secondToFirst_
HashTable21 _secondToFirst_
Definition bijection.h:619

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::toString
std::string toString() const

gum::BijectionImplementation::type1_const_reference
const T1 & type1_const_reference
types for STL compliance
Definition bijection.h:110

gum::BijectionImplementation::type2_const_reference
const T2 & type2_const_reference
types for STL compliance
Definition bijection.h:115

gum::BijectionImplementation::iterator
BijectionIterator< T1, T2 > iterator
types for STL compliance
Definition bijection.h:120

gum::BijectionImplementation::type2_type
T2 type2_type
types for STL compliance
Definition bijection.h:113

gum::BijectionImplementation::BijectionImplementation
BijectionImplementation(Size size, bool resize_policy)
Default constructor: creates a gum::Bijection without any association.
Definition bijection_tpl.h:87

gum::BijectionImplementation::operator=
BijectionImplementation< T1, T2, Gen > & operator=(const BijectionImplementation< T1, T2, Gen > &toCopy)
Copy operator.
Definition bijection_tpl.h:147

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::cbeginSafe
const_iterator_safe cbeginSafe() const

gum::BijectionImplementation::type2_reference
T2 & type2_reference
types for STL compliance
Definition bijection.h:114

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::second
const T2 & second(const T1 &first) const

gum::BijectionImplementation::type1_reference
T1 & type1_reference
types for STL compliance
Definition bijection.h:109

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::tryFirst
optional_ref< const T1 > tryFirst(const T2 &second) const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::empty
bool empty() const noexcept

gum::BijectionImplementation::BijectionIterator< T1, T2 >
friend class BijectionIterator< T1, T2 >
a friend to speed-up accesses
Definition bijection.h:604

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::insert
void insert(const T1 &first, const T2 &second)

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::resize
void resize(Size new_size)

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::secondWithDefault
const T2 & secondWithDefault(const T1 &second, const T2 &default_val) const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_
HashTable12::value_type * _insert_(const T1 &first, const T2 &second)

gum::BijectionImplementation::Bijection< T1, T2 >
friend class Bijection< T1, T2 >
a friend to speed-up accesses
Definition bijection.h:605

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::capacity
Size capacity() const noexcept

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::existsSecond
bool existsSecond(const T2 &second) const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::first
const T1 & first(const T2 &second) const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_copy_
void _copy_(const HashTable< T1, T2 * > &source)

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::clear
void clear()

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::size
Size size() const noexcept

gum::BijectionImplementation::~BijectionImplementation
~BijectionImplementation()
Destructor.
Definition bijection_tpl.h:131

gum::BijectionImplementation::operator=
BijectionImplementation< T1, T2, Gen > & operator=(BijectionImplementation< T1, T2, Gen > &&toCopy)
Move operator.
Definition bijection_tpl.h:163

gum::BijectionImplementation::HashTable12
HashTable< T1, T2 * > HashTable12
Alias for more readable code.
Definition bijection.h:597

gum::BijectionImplementation::type1_pointer
T1 * type1_pointer
types for STL compliance
Definition bijection.h:111

gum::BijectionImplementation::BijectionImplementation
BijectionImplementation(BijectionImplementation< T1, T2, Gen > &&from) noexcept
Move constructor.
Definition bijection_tpl.h:122

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::eraseFirst
void eraseFirst(const T1 &first)

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::beginSafe
iterator_safe beginSafe() const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::eraseSecond
void eraseSecond(const T2 &second)

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::cend
const const_iterator & cend() const noexcept

gum::BijectionImplementation::BijectionIteratorSafe< T1, T2 >
friend class BijectionIteratorSafe< T1, T2 >
a friend to speed-up accesses
Definition bijection.h:603

gum::BijectionImplementation::begin
iterator begin() const
Returns the unsafe iterator at the beginning of the gum::Bijection.
Definition bijection_tpl.h:181

gum::BijectionImplementation::BijectionImplementation
friend class BijectionImplementation
a friend to speed-up accesses
Definition bijection.h:607

gum::BijectionImplementation::BijectionImplementation
BijectionImplementation(std::initializer_list< std::pair< T1, T2 > > list)
Initializer list constructor.
Definition bijection_tpl.h:99

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::existsFirst
bool existsFirst(const T1 &first) const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::firstWithDefault
const T1 & firstWithDefault(const T2 &second, const T1 &default_val) const

gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::cendSafe
const const_iterator_safe & cendSafe() const noexcept

gum::BijectionIteratorSafe
Safe iterators for bijectionIterator.
Definition bijection.h:1240

gum::BijectionIteratorSafe::type2_pointer
T2 * type2_pointer
types for STL compliance
Definition bijection.h:1256

gum::BijectionIteratorSafe::_iter_
HashIter _iter_
The hashTable iterator that actually does all the job.
Definition bijection.h:1423

gum::BijectionIteratorSafe::type1_const_pointer
const T1 * type1_const_pointer
types for STL compliance
Definition bijection.h:1252

gum::BijectionIteratorSafe::HashIter
typename HashTable12::const_iterator_safe HashIter
Alias for one of the internal gum::HastTableIterator of the gum::Bijection.
Definition bijection.h:1420

gum::BijectionIteratorSafe::Getter
BijectionIteratorGet< std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value > Getter
Dummy classes that will enable discriminate without overhead between scalars and non-scalars function...
Definition bijection.h:1266

gum::BijectionIteratorSafe::type1_const_reference
const T1 & type1_const_reference
types for STL compliance
Definition bijection.h:1250

gum::BijectionIteratorSafe::second
const T2 & second() const
Returns the second element of the current association.
Definition bijection_tpl.h:912

gum::BijectionIteratorSafe::type1_pointer
T1 * type1_pointer
types for STL compliance
Definition bijection.h:1251

gum::BijectionIteratorSafe::type2_const_reference
const T2 & type2_const_reference
types for STL compliance
Definition bijection.h:1255

gum::BijectionIteratorSafe::type1_reference
T1 & type1_reference
types for STL compliance
Definition bijection.h:1249

gum::BijectionIteratorSafe::BijectionIteratorSafe
BijectionIteratorSafe(const BijectionImplementation< T1, T2, Gen > &bijection)
Begin constructor.
Definition bijection_tpl.h:823

gum::BijectionIteratorSafe::type1_type
T1 type1_type
types for STL compliance
Definition bijection.h:1248

gum::BijectionIteratorSafe::type2_const_pointer
const T2 * type2_const_pointer
types for STL compliance
Definition bijection.h:1257

gum::BijectionIteratorSafe::HashTable12
typename std::conditional< std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value, HashTable< T1, T2 >, HashTable< T1, T2 * > >::type HashTable12
Alias for one of the internal gum::HashTable of the gum::Bijection.
Definition bijection.h:1413

gum::BijectionIteratorSafe::difference_type
std::ptrdiff_t difference_type
types for STL compliance
Definition bijection.h:1258

gum::BijectionIteratorSafe::first
const T1 & first() const
Returns the first element of the current association.
Definition bijection_tpl.h:906

gum::BijectionIteratorSafe::type2_type
T2 type2_type
types for STL compliance
Definition bijection.h:1253

gum::BijectionIteratorSafe::iterator_category
std::forward_iterator_tag iterator_category
types for STL compliance
Definition bijection.h:1247

gum::BijectionIteratorSafe::BijectionImplementation
friend class BijectionImplementation
Definition bijection.h:1242

gum::BijectionIteratorSafe::type2_reference
T2 & type2_reference
types for STL compliance
Definition bijection.h:1254

gum::BijectionIterator
Unsafe iterators for bijection.
Definition bijection.h:1440

gum::BijectionIterator::type1_pointer
T1 * type1_pointer
types for STL compliance
Definition bijection.h:1451

gum::BijectionIterator::type1_type
T1 type1_type
types for STL compliance
Definition bijection.h:1448

gum::BijectionIterator::HashTable12
typename std::conditional< std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value, HashTable< T1, T2 >, HashTable< T1, T2 * > >::type HashTable12
Alias for one of the internal gum::HashTable of the gum::Bijection.
Definition bijection.h:1607

gum::BijectionIterator::BijectionIterator
BijectionIterator(const BijectionImplementation< T1, T2, Gen > &bijection)
Begin constructor.
Definition bijection_tpl.h:932

gum::BijectionIterator::HashIter
typename HashTable12::const_iterator HashIter
Definition bijection.h:1611

gum::BijectionIterator::first
const T1 & first() const
Returns the first element of the current association.
Definition bijection_tpl.h:1014

gum::BijectionIterator::type2_pointer
T2 * type2_pointer
types for STL compliance
Definition bijection.h:1456

gum::BijectionIterator::type1_reference
T1 & type1_reference
types for STL compliance
Definition bijection.h:1449

gum::BijectionIterator::type2_reference
T2 & type2_reference
types for STL compliance
Definition bijection.h:1454

gum::BijectionIterator::type2_const_reference
const T2 & type2_const_reference
types for STL compliance
Definition bijection.h:1455

gum::BijectionIterator::type1_const_reference
const T1 & type1_const_reference
types for STL compliance
Definition bijection.h:1450

gum::BijectionIterator::Getter
BijectionIteratorGet< std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value > Getter
Dummy classes that will enable discriminate without overhead between scalars and non-scalars function...
Definition bijection.h:1466

gum::BijectionIterator::type2_type
T2 type2_type
types for STL compliance
Definition bijection.h:1453

gum::BijectionIterator::_iter_
HashIter _iter_
The hashTable iterator that actually does all the job.
Definition bijection.h:1614

gum::BijectionIterator::difference_type
std::ptrdiff_t difference_type
types for STL compliance
Definition bijection.h:1458

gum::BijectionIterator::iterator_category
std::forward_iterator_tag iterator_category
types for STL compliance
Definition bijection.h:1447

gum::BijectionIterator::type1_const_pointer
const T1 * type1_const_pointer
types for STL compliance
Definition bijection.h:1452

gum::BijectionIterator::second
const T2 & second() const
Returns the second element of the current association.
Definition bijection_tpl.h:1020

gum::BijectionIterator::type2_const_pointer
const T2 * type2_const_pointer
types for STL compliance
Definition bijection.h:1457

gum::BijectionIterator::BijectionImplementation
friend class BijectionImplementation
Definition bijection.h:1442

gum::Bijection
Set of pairs of elements with fast search for both elements.
Definition bijection.h:1640

gum::Bijection::type1_const_pointer
const T1 * type1_const_pointer
types for STL compliance
Definition bijection.h:1648

gum::Bijection::Implementation
BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value > Implementation
The Implementation of this gum::Bijection.
Definition bijection.h:1663

gum::Bijection::type2_reference
T2 & type2_reference
types for STL compliance
Definition bijection.h:1650

gum::Bijection::type2_pointer
T2 * type2_pointer
types for STL compliance
Definition bijection.h:1652

gum::Bijection< const DiscreteVariable *, const DiscreteVariable * >::operator=
Bijection< const DiscreteVariable *, const DiscreteVariable * > & operator=(const Bijection< const DiscreteVariable *, const DiscreteVariable * > &toCopy)

gum::Bijection::Bijection
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.
Definition bijection_tpl.h:1030

gum::Bijection::type1_const_reference
const T1 & type1_const_reference
types for STL compliance
Definition bijection.h:1646

gum::Bijection::iterator_safe
BijectionIteratorSafe< T1, T2 > iterator_safe
types for STL compliance
Definition bijection.h:1658

gum::Bijection::const_iterator_safe
BijectionIteratorSafe< T1, T2 > const_iterator_safe
types for STL compliance
Definition bijection.h:1659

gum::Bijection::type2_type
T2 type2_type
types for STL compliance
Definition bijection.h:1649

gum::Bijection::type1_pointer
T1 * type1_pointer
types for STL compliance
Definition bijection.h:1647

gum::Bijection::difference_type
std::ptrdiff_t difference_type
types for STL compliance
Definition bijection.h:1655

gum::Bijection::type2_const_pointer
const T2 * type2_const_pointer
types for STL compliance
Definition bijection.h:1653

gum::Bijection::type1_type
T1 type1_type
types for STL compliance
Definition bijection.h:1644

gum::Bijection::type2_const_reference
const T2 & type2_const_reference
types for STL compliance
Definition bijection.h:1651

gum::Bijection::type1_reference
T1 & type1_reference
types for STL compliance
Definition bijection.h:1645

gum::Bijection::const_iterator
BijectionIterator< T1, T2 > const_iterator
types for STL compliance
Definition bijection.h:1657

gum::Bijection::iterator
BijectionIterator< T1, T2 > iterator
types for STL compliance
Definition bijection.h:1656

gum::Bijection::size_type
std::size_t size_type
types for STL compliance
Definition bijection.h:1654

gum::HashTable
The class for generic Hash Tables.
Definition hashTable.h:640

gum::optional_ref
A lightweight wrapper around a pointer providing an optional-like API for references (not supported b...
Definition optional_ref.h:62

gum::Size
std::size_t Size
In aGrUM, hashed values are unsigned long int.
Definition types.h:74

hashTable.h
Class hash tables iterators.

gum
gum is the global namespace for all aGrUM entities
Definition agrum.h:46

gum::StaticInitializer
StaticInitializer
Definition staticInitializer.h:68

std
STL namespace.

gum::BijectionIteratorGet< true >::op_second
static const T & op_second(const T &x)
Returns a reference.
Definition bijection_tpl.h:1095

gum::BijectionIteratorGet
Dummy classes for discriminating scalars and non-scalars operators and -> wihtout any overhead.
Definition bijection.h:1196

gum::BijectionIteratorGet::op_second
static const T & op_second(const T *x)
Returns a refeence over a pointer.
Definition bijection_tpl.h:1090

gum::HashTableConst::default_size
static constexpr Size default_size
The default number of slots in hashtables.
Definition hashTable.h:102

gum::HashTableConst::default_resize_policy
static constexpr bool default_resize_policy
A Boolean indicating whether inserting too many values into the hashtable makes it resize itself auto...
Definition hashTable.h:116

operator<<
std::ostream & operator<<(std::ostream &out, const TiXmlNode &base)
Definition tinyxml.cpp:1516