A non scalar implementation of a Bijection. More...

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

Inheritance diagram for gum::BijectionImplementation< T1, T2, Gen >:

Collaboration diagram for gum::BijectionImplementation< T1, T2, Gen >:

Public Types

using	type1_type = T1
	types for STL compliance
using	type1_reference = T1&
	types for STL compliance
using	type1_const_reference = const T1&
	types for STL compliance
using	type1_pointer = T1*
	types for STL compliance
using	type1_const_pointer = const T1*
	types for STL compliance
using	type2_type = T2
	types for STL compliance
using	type2_reference = T2&
	types for STL compliance
using	type2_const_reference = const T2&
	types for STL compliance
using	type2_pointer = T2*
	types for STL compliance
using	type2_const_pointer = const T2*
	types for STL compliance
using	size_type = std::size_t
	types for STL compliance
using	difference_type = std::ptrdiff_t
	types for STL compliance
using	iterator = BijectionIterator< T1, T2 >
	types for STL compliance
using	const_iterator = BijectionIterator< T1, T2 >
	types for STL compliance
using	iterator_safe = BijectionIteratorSafe< T1, T2 >
	types for STL compliance
using	const_iterator_safe = BijectionIteratorSafe< T1, T2 >
	types for STL compliance

Public Member Functions
template<typename T1, typename T2>
	BijectionImplementation (const BijectionImplementation< T1, T2, true > &toCopy)
template<typename T1, typename T2>
	BijectionImplementation (BijectionImplementation< T1, T2, true > &&toCopy) noexcept
Constructors/destructors
	~BijectionImplementation ()
	Destructor.
Iterators
iterator	begin () const
	Returns the unsafe iterator at the beginning of the gum::Bijection.
const_iterator	cbegin () const
	Returns the constant unsafe iterator at the beginning of the gum::Bjection.
const iterator &	end () const noexcept
	Returns the unsafe iterator at the end of the gum::Bijection.
const const_iterator &	cend () const noexcept
	Returns the constant iterator at the end of the gum::Bijection.
iterator_safe	beginSafe () const
	Returns the safe iterator at the beginning of the gum::Bijection.
const_iterator_safe	cbeginSafe () const
	Returns the constant safe iterator at the begining of the gum::Bijection.
const iterator_safe &	endSafe () const noexcept
	Returns the safe iterator at the end of the gum::Bijection.
const const_iterator_safe &	cendSafe () const noexcept
	Returns the constant safe iterator at the end of the gum::Bijection.
Accessors / Modifiers
const T1 &	first (const T2 &second) const
	Returns the first value of a pair given its second value.
const T1 &	firstWithDefault (const T2 &second, const T1 &default_val) const
	Returns the first value of a pair given its second value or default_val if second is unfound.
const T2 &	second (const T1 &first) const
	Returns the second value of a pair given its first value.
template<typename K>
const T2 &	second (const K &first) const
	Heterogeneous overload: accepts any type convertible to string_view when T1=std::string.
const T2 &	secondWithDefault (const T1 &second, const T2 &default_val) const
	Returns the second value of a pair given its first value or default_val if first is unfound.
bool	existsFirst (const T1 &first) const
	Returns true if first is the first element in a pair in the gum::Bijection.
template<typename K>
bool	existsFirst (const K &first) const
	Heterogeneous overload: accepts any type convertible to string_view when T1=std::string.
bool	existsSecond (const T2 &second) const
	Returns true if second is the second element in a pair in the gum::Bijection.
optional_ref< const T1 >	tryFirst (const T2 &second) const
	Returns a pointer to the first value associated with the given second value, or nullptr if not found.
optional_ref< const T2 >	trySecond (const T1 &first) const
	Returns an optional reference to the second value associated with the given first value, or empty if not found.
template<typename K>
optional_ref< const T2 >	trySecond (const K &first) const
	Heterogeneous overload: accepts any type convertible to string_view when T1=std::string.
void	insert (const T1 &first, const T2 &second)
	Inserts a new association in the gum::Bijection.
void	insert (T1 &&first, T2 &&second)
	Inserts a new association in the gum::Bijection.
template<typename... Args>
void	emplace (Args &&... args)
	Emplace a new element in the gum::Bijection.
void	clear ()
	Removes all the associations from the gum::Bijection.
bool	empty () const noexcept
	Returns true if the gum::Bijection doesn't contain any association.
Size	size () const noexcept
	Returns the number of associations stored within the gum::Bijection.
void	eraseFirst (const T1 &first)
	Erases an association containing the given first element.
void	eraseSecond (const T2 &second)
	Erases an association containing the given second element.
std::string	toString () const
	Returns a friendly representatin of the gum::Bijection.
Fine tuning
Size	capacity () const noexcept
	Returns the number of hashtables slots used.
void	resize (Size new_size)
	Manually resize the gum::Bijection.
void	setResizePolicy (const bool new_policy) noexcept
	Change the gum::Bijection resizing policy.
bool	resizePolicy () const noexcept
	Returns true if the resize policy is automatic.

Private Types

using	HashTable12 = HashTable< T1, T2* >
	Alias for more readable code.
using	HashTable21 = HashTable< T2, T1* >
	Alias for more readable code.

Private Member Functions
	BijectionImplementation (Size size, bool resize_policy)
	Default constructor: creates a gum::Bijection without any association.
	BijectionImplementation (std::initializer_list< std::pair< T1, T2 > > list)
	Initializer list constructor.
	BijectionImplementation (const BijectionImplementation< T1, T2, Gen > &toCopy)
	Copy constructor.
	BijectionImplementation (BijectionImplementation< T1, T2, Gen > &&from) noexcept
	Move constructor.
BijectionImplementation< T1, T2, Gen > &	operator= (const BijectionImplementation< T1, T2, Gen > &toCopy)
	Copy operator.
BijectionImplementation< T1, T2, Gen > &	operator= (BijectionImplementation< T1, T2, Gen > &&toCopy)
	Move operator.
void	_copy_ (const HashTable< T1, T2 * > &source)
	A function that performs a complete copy of another gum::Bijection.
HashTable12::value_type *	_insert_ (const T1 &first, const T2 &second)
	Inserts a new association into the gum::Bijection.
HashTable12::value_type *	_insert_ (T1 &&first, T2 &&second)
	Inserts a new association into the gum::Bijection.

Private Attributes
HashTable12	_firstToSecond_
	The gum::HashTable associating T2 objects to T1 objects.
HashTable21	_secondToFirst_
	The gum::HashTable associating T1 objects to T2 objects.

Friends

class	BijectionIteratorSafe< T1, T2 >
	a friend to speed-up accesses
class	BijectionIterator< T1, T2 >
	a friend to speed-up accesses
class	Bijection< T1, T2 >
	a friend to speed-up accesses
template<typename TT1, typename TT2, bool>
class	BijectionImplementation
	a friend to speed-up accesses

Detailed Description

template<typename T1, typename T2, bool Gen>
class gum::BijectionImplementation< T1, T2, Gen >

A non scalar implementation of a Bijection.

This class is designed for modeling a gum::Bijection between two sets, the idea is following :

We want to create a gum::Bjection relation between type T1 and type T2,
For x in T1, there exists only one y in T2 associated to x,
For y in T2, there exists only one x in T1 associated to y,
The user inserts all the (x, y) associations and can search efficiently the values thus associated.

Template Parameters

T1	The first type of elements in the gum::Bjection.
T2	The second type of elements in the gum::Bjection.
Gen	If true, this will be replaced by a implementation omptimized for non-scalar types.

Definition at line 104 of file bijection.h.

Member Typedef Documentation

◆ const_iterator

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::const_iterator = BijectionIterator< T1, T2 >

types for STL compliance

Definition at line 121 of file bijection.h.

◆ const_iterator_safe

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::const_iterator_safe = BijectionIteratorSafe< T1, T2 >

types for STL compliance

Definition at line 123 of file bijection.h.

◆ difference_type

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::difference_type = std::ptrdiff_t

types for STL compliance

Definition at line 119 of file bijection.h.

◆ HashTable12

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::HashTable12 = HashTable< T1, T2* >

private

Alias for more readable code.

Definition at line 597 of file bijection.h.

◆ HashTable21

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::HashTable21 = HashTable< T2, T1* >

private

Alias for more readable code.

Definition at line 598 of file bijection.h.

◆ iterator

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::iterator = BijectionIterator< T1, T2 >

types for STL compliance

Definition at line 120 of file bijection.h.

◆ iterator_safe

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::iterator_safe = BijectionIteratorSafe< T1, T2 >

types for STL compliance

Definition at line 122 of file bijection.h.

◆ size_type

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::size_type = std::size_t

types for STL compliance

Definition at line 118 of file bijection.h.

◆ type1_const_pointer

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type1_const_pointer = const T1*

types for STL compliance

Definition at line 112 of file bijection.h.

◆ type1_const_reference

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type1_const_reference = const T1&

types for STL compliance

Definition at line 110 of file bijection.h.

◆ type1_pointer

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type1_pointer = T1*

types for STL compliance

Definition at line 111 of file bijection.h.

◆ type1_reference

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type1_reference = T1&

types for STL compliance

Definition at line 109 of file bijection.h.

◆ type1_type

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type1_type = T1

types for STL compliance

Definition at line 108 of file bijection.h.

◆ type2_const_pointer

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type2_const_pointer = const T2*

types for STL compliance

Definition at line 117 of file bijection.h.

◆ type2_const_reference

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type2_const_reference = const T2&

types for STL compliance

Definition at line 115 of file bijection.h.

◆ type2_pointer

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type2_pointer = T2*

types for STL compliance

Definition at line 116 of file bijection.h.

◆ type2_reference

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type2_reference = T2&

types for STL compliance

Definition at line 114 of file bijection.h.

◆ type2_type

template<typename T1, typename T2, bool Gen>

using gum::BijectionImplementation< T1, T2, Gen >::type2_type = T2

types for STL compliance

Definition at line 113 of file bijection.h.

Constructor & Destructor Documentation

◆ BijectionImplementation() [1/6]

template<typename T1, typename T2>

gum::BijectionImplementation< T1, T2 >::BijectionImplementation	(	Size	size,
		bool	resize_policy )

private

Default constructor: creates a gum::Bijection without any association.

Parameters

size	The Bijection starting size.
resize_policy	If true, the gum::Bijection will resize itself automatically.

Definition at line 87 of file bijection_tpl.h.

                                                                                               :
      // warning: below, we create the internal hashTables with a key
      // uniqueness
      // policy set to false because we will do the uniqueness tests ourselves
      // (this
      // will speed-up the process)
      _firstToSecond_(size, resize_policy, false), _secondToFirst_(size, resize_policy, false) {
    GUM_CONSTRUCTOR(BijectionImplementation);
  }

References BijectionImplementation, _firstToSecond_, _secondToFirst_, and size().

Here is the call graph for this function:

◆ BijectionImplementation() [2/6]

template<typename T1, typename T2>

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

private

Initializer list constructor.

Parameters

list	The initialize list.

Definition at line 99 of file bijection_tpl.h.

                                                     :
      _firstToSecond_(Size(list.size()) / 2, true, false),
      _secondToFirst_(Size(list.size()) / 2, true, false) {
    GUM_CONSTRUCTOR(BijectionImplementation);
 
    for (const auto& elt: list) {
      insert(elt.first, elt.second);
    }
  }

References BijectionImplementation, _firstToSecond_, _secondToFirst_, insert(), and size().

Here is the call graph for this function:

◆ BijectionImplementation() [3/6]

template<typename T1, typename T2, bool Gen>

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

private

Copy constructor.

Parameters

toCopy Bijection to copy.

Definition at line 112 of file bijection_tpl.h.

                                                            :
      _firstToSecond_(toCopy._firstToSecond_.capacity(), true, false),
      _secondToFirst_(toCopy._secondToFirst_.capacity(), true, false) {
    GUM_CONS_CPY(BijectionImplementation);
    _copy_(toCopy._firstToSecond_);
  }

References BijectionImplementation, _copy_(), _firstToSecond_, _secondToFirst_, and capacity().

Here is the call graph for this function:

◆ BijectionImplementation() [4/6]

template<typename T1, typename T2, bool Gen>

gum::BijectionImplementation< T1, T2, Gen >::BijectionImplementation ( BijectionImplementation< T1, T2, Gen > && from )

privatenoexcept

Move constructor.

Parameters

from	Bijection to move.

Definition at line 122 of file bijection_tpl.h.

                                                              :
      _firstToSecond_(std::move(from._firstToSecond_)),
      _secondToFirst_(std::move(from._secondToFirst_)) {
    GUM_CONS_MOV(BijectionImplementation);
  }

References BijectionImplementation, _firstToSecond_, and _secondToFirst_.

Here is the call graph for this function:

◆ ~BijectionImplementation()

template<typename T1, typename T2>

gum::BijectionImplementation< T1, T2 >::~BijectionImplementation ( )

Destructor.

Definition at line 131 of file bijection_tpl.h.

                                                                   {
    GUM_DESTRUCTOR(BijectionImplementation);
  }

References BijectionImplementation.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BijectionImplementation() [5/6]

template<typename T1, typename T2, bool Gen>

template<typename T1, typename T2>

gum::BijectionImplementation< T1, T2, Gen >::BijectionImplementation ( const BijectionImplementation< T1, T2, true > & toCopy )

Definition at line 523 of file bijection_tpl.h.

                                                             :
      _firstToSecond_(toCopy._firstToSecond_.capacity(), true, false),
      _secondToFirst_(toCopy._secondToFirst_.capacity(), true, false) {
    GUM_CONS_CPY(BijectionImplementation);
    _copy_(toCopy._firstToSecond_);
  }

◆ BijectionImplementation() [6/6]

template<typename T1, typename T2, bool Gen>

template<typename T1, typename T2>

gum::BijectionImplementation< T1, T2, Gen >::BijectionImplementation ( BijectionImplementation< T1, T2, true > && toCopy )

noexcept

Definition at line 533 of file bijection_tpl.h.

                                                                 :
      _firstToSecond_(std::move(toCopy._firstToSecond_)),
      _secondToFirst_(std::move(toCopy._secondToFirst_)) {
    GUM_CONS_MOV(BijectionImplementation);
  }

Member Function Documentation

◆ _copy_()

template<typename T1, typename T2, bool Gen>

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

private

A function that performs a complete copy of another gum::Bijection.

Warning: this function assumes that "this" is an empty gum::Bijection. If it is not the case, use function clear() before calling copy.

Parameters

source The source from copied into this gum::Bijection.

Definition at line 63 of file bijection_tpl.h.

                                                                                     {
    // parse f2s and perform copies
    for (auto iter = f2s.cbegin(); iter != f2s.cend(); ++iter) {
      typename HashTable12::value_type* val1 = &(_firstToSecond_.insert(iter.key(), nullptr));
      typename HashTable21::value_type* val2;
 
      try {
        val2 = &(_secondToFirst_.insert(*(iter.val()), nullptr));
      } catch (...) {
        _firstToSecond_.erase(iter.key());
        throw;
      }
 
      val1->second = &(const_cast< T2& >(val2->first));
      val2->second = &(const_cast< T1& >(val1->first));
    }
 
    // note that  _iter_end_ is actually a constant, whatever we add/remove
    // to/from  _firstToSecond_. As a consequence, it need not be updated
    // after  _copy_
  }

References _firstToSecond_, _secondToFirst_, gum::HashTable< Key, Val >::cbegin(), and gum::HashTable< Key, Val >::cend().

Referenced by BijectionImplementation(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _insert_() [1/2]

template<typename T1, typename T2, bool Gen>

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

private

Inserts a new association into the gum::Bijection.

Parameters

first	The first object in the association.
second	The second object in the association.

Returns: Returns a pointer toward the inserted association.

Definition at line 305 of file bijection_tpl.h.

                                                                                        {
    // check the uniqueness property
    if (existsFirst(first) || existsSecond(second)) {
      GUM_ERROR(DuplicateElement,
                "the bijection contains an element with the same couple (" << first << "," << second
                                                                           << ")");
    }
 
    // insert copies of first and second
    typename HashTable12::value_type* val1 = &(_firstToSecond_.insert(first, nullptr));
    typename HashTable21::value_type* val2;
 
    try {
      val2 = &(_secondToFirst_.insert(second, nullptr));
    } catch (...) {
      _firstToSecond_.erase(first);
      throw;
    }
 
    val1->second = &(const_cast< T2& >(val2->first));
    val2->second = &(const_cast< T1& >(val1->first));
 
    return val1;
  }

References _firstToSecond_, _secondToFirst_, existsFirst(), existsSecond(), first(), GUM_ERROR, and second().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), emplace(), firstWithDefault(), insert(), and insert().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _insert_() [2/2]

template<typename T1, typename T2, bool Gen>

BijectionImplementation< T1, T2, Gen >::HashTable12::value_type * gum::BijectionImplementation< T1, T2, Gen >::_insert_	(	T1 &&	first,
		T2 &&	second )

private

Inserts a new association into the gum::Bijection.

Parameters

first	The first object in the association.
second	The second object in the association.

Returns: Returns a pointer toward the inserted association.

Definition at line 333 of file bijection_tpl.h.

                                                                              {
    // check the uniqueness property
    if (existsFirst(first) || existsSecond(second)) {
      GUM_ERROR(DuplicateElement,
                "the bijection contains an element with the same couple (" << first << "," << second
                                                                           << ")");
    }
 
    // insert copies of first and second
    typename HashTable12::value_type* val1 = &(_firstToSecond_.insert(std::move(first), nullptr));
    typename HashTable21::value_type* val2;
 
    try {
      val2 = &(_secondToFirst_.insert(std::move(second), nullptr));
    } catch (...) {
      _firstToSecond_.erase(val1->first);
      throw;
    }
 
    val1->second = &(const_cast< T2& >(val2->first));
    val2->second = &(const_cast< T1& >(val1->first));
 
    return val1;
  }

References _firstToSecond_, _secondToFirst_, existsFirst(), existsSecond(), first(), GUM_ERROR, and second().

Here is the call graph for this function:

◆ begin()

template<typename T1, typename T2>

BijectionImplementation< T1, T2, true >::iterator gum::BijectionImplementation< T1, T2 >::begin ( ) const

Returns the unsafe iterator at the beginning of the gum::Bijection.

Unsafe iterators are a little bit faster than safe ones. But this speed is at the expense of safety: if you point to an element that is deleted, then try to access it or trying to operate a ++ will most certainly result in a segfault. So, Unsafe iterators should only be used to parse gum::Bjection where no element is ever deleted. If unsure, prefer using safe iterators.

Note that the notion of a beginning/end of a gum::Bjection is rather fuzzy. What is important here is that for an instance bij of this class:

for(iterator iter = bij.begin(); iter != bij.end(); ++iter) {
  // will parse all the associations.
}

Definition at line 181 of file bijection_tpl.h.

                                                          {
    return BijectionIterator< T1, T2 >{*this};
  }

References BijectionIterator< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), and toString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ beginSafe()

template<typename T1, typename T2>

BijectionImplementation< T1, T2, true >::iterator_safe gum::BijectionImplementation< T1, T2 >::beginSafe ( ) const

Returns the safe iterator at the beginning of the gum::Bijection.

Safe iterators are slightly slower than unsafe iterators. However, they guarantee that no segmentation fault can ever occur when trying to access the element they point to or when applying a ++ operator. When no element of the gum::Bijection is to be deleted during the parsing of the gum::Bijection (as for instance when you parse the gum::Bijection to display its content), prefer using the unsafe iterators, which are a little bit faster and cannot, in this case, produce segfaults.

Note that the notion of a beginning/end of a gum::Bijection is rather fuzzy. What is important here is that for an instance bij of this class:

for (iterator iter = bij.beginSafe(); iter != bij.endSafe(); ++iter) {
  // loops will parse all the associations
}

Definition at line 209 of file bijection_tpl.h.

                                                              {
    return BijectionIteratorSafe< T1, T2 >{*this};
  }

References BijectionIteratorSafe< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ capacity()

template<typename T1, typename T2>

Size gum::BijectionImplementation< T1, T2 >::capacity ( ) const

noexcept

Returns the number of hashtables slots used.

Returns: Returns the number of hashtables slots used.

Definition at line 430 of file bijection_tpl.h.

                                                                       {
    return _firstToSecond_.capacity();
  }

References _firstToSecond_.

Referenced by BijectionImplementation(), and gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the caller graph for this function:

◆ cbegin()

template<typename T1, typename T2>

BijectionImplementation< T1, T2, true >::const_iterator gum::BijectionImplementation< T1, T2 >::cbegin ( ) const

Returns the constant unsafe iterator at the beginning of the gum::Bjection.

Unsafe iterators are a little bit faster than safe ones. But this speed is at the expense of safety: if you point to an element that is deleted, then try to access it or trying to operate a ++ will most certainly result in a segfault. So, Unsafe iterators should only be used to parse gum::Bjection where no element is ever deleted. If unsure, prefer using safe iterators.

Note that the notion of a beginning/end of a gum::Bjection is rather fuzzy. What is important here is that for an instance bij of this class:

for (iterator iter = bij.cbegin(); iter != bij.cend(); ++iter) {
  // will parse all the association
}

Definition at line 188 of file bijection_tpl.h.

                                                           {
    return BijectionIterator< T1, T2 >{*this};
  }

References BijectionIterator< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cbeginSafe()

template<typename T1, typename T2>

BijectionImplementation< T1, T2, true >::const_iterator_safe gum::BijectionImplementation< T1, T2 >::cbeginSafe ( ) const

Returns the constant safe iterator at the begining of the gum::Bijection.

Safe iterators are slightly slower than unsafe iterators. However, they guarantee that no segmentation fault can ever occur when trying to access the element they point to or when applying a ++ operator. When no element of the gum::Bijection is to be deleted during the parsing of the gum::Bijection (as for instance when you parse the bijection to display its content), prefer using the unsafe iterators, which are a little bit faster and cannot, in this case, produce segfaults.

Note that the notion of a beginning/end of a gum::Bijection is rather fuzzy. What is important here is that for an instance bij of this class:

for (iterator iter = bij.cbeginSafe(); iter != bij.cendSafe(); ++iter) {
  // loops will parse all the associations
}

Definition at line 216 of file bijection_tpl.h.

                                                               {
    return BijectionIteratorSafe< T1, T2 >{*this};
  }

References BijectionIteratorSafe< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cend()

template<typename T1, typename T2>

const BijectionImplementation< T1, T2, true >::const_iterator & gum::BijectionImplementation< T1, T2 >::cend ( ) const

noexcept

Returns the constant iterator at the end of the gum::Bijection.

Unsafe iterators are a little bit faster than safe ones. But this speed is at the expense of safety: if you point to an element that is deleted, then try to access it or trying to operate a ++ will most certainly result in a segfault. So, Unsafe iterators should only be used to parse gum::Bijection where no element is ever deleted. If unsure, prefer using safe iterators.

Note that the notion of a beginning/end of a gum::Bijection is rather fuzzy. What is important here is that for an instance bij of this class:

for (iterator iter = bij.cbegin(); iter != bij.cend(); ++iter) {
  // loops will parse all the associations
}

Definition at line 202 of file bijection_tpl.h.

                                                                  {
    return *(reinterpret_cast< const BijectionIterator< T1, T2 >* >(_Bijection_end_));
  }

References BijectionIterator< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cendSafe()

template<typename T1, typename T2>

const BijectionImplementation< T1, T2, true >::const_iterator_safe & gum::BijectionImplementation< T1, T2 >::cendSafe ( ) const

noexcept

Returns the constant safe iterator at the end of the gum::Bijection.

Safe iterators are slightly slower than unsafe iterators. However, they guarantee that no segmentation fault can ever occur when trying to access the element they point to or when applying a ++ operator. When no element of the gum::Bijection is to be deleted during the parsing of the gum::Bijection (as for instance when you parse the gum::Bijection to display its content), prefer using the unsafe iterators, which are a little bit faster and cannot, in this case, produce segfaults.

Note that the notion of a beginning/end of a gum::Bijection is rather fuzzy. What is important here is that for an instance bij of this class:

for (iterator iter = bij.cbeginSafe(); iter != bij.cendSafe(); ++iter) {
  // loops will parse all the associations
}

Definition at line 230 of file bijection_tpl.h.

                                                                      {
    return *(reinterpret_cast< const BijectionIteratorSafe< T1, T2 >* >(_Bijection_end_safe_));
  }

References BijectionIteratorSafe< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

template<typename T1, typename T2>

void gum::BijectionImplementation< T1, T2 >::clear ( )

Removes all the associations from the gum::Bijection.

Definition at line 137 of file bijection_tpl.h.

                                                     {
    _firstToSecond_.clear();
    _secondToFirst_.clear();
    // note that  _iter_end_ is actually a constant, whatever we add/remove
    // to/from  _firstToSecond_. As a consequence, it need not be updated
    // after the clear's
  }

References _firstToSecond_, and _secondToFirst_.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), operator=(), and operator=().

Here is the caller graph for this function:

◆ emplace()

template<typename T1, typename T2>

template<typename... Args>

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

Emplace a new element in the gum::Bijection.

The emplace method allows to construct directly an element of type Key by passing to its constructor all the arguments it needs.

Parameters

args	the arguments passed to the constructor

Exceptions

DuplicateElement exception is thrown if the association already exists

Definition at line 391 of file bijection_tpl.h.

                                                                     {
    std::pair< T1, T2 > new_elt(std::forward< Args >(args)...);
    _insert_(std::move(new_elt.first), std::move(new_elt.second));
  }

References _insert_().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ empty()

template<typename T1, typename T2>

bool gum::BijectionImplementation< T1, T2 >::empty ( ) const

noexcept

Returns true if the gum::Bijection doesn't contain any association.

Returns: Returns true if the gum::Bijection doesn't contain any association.

Definition at line 398 of file bijection_tpl.h.

                                                                    {
    GUM_ASSERT(_firstToSecond_.empty() == _secondToFirst_.empty());
    return _firstToSecond_.empty();
  }

References _firstToSecond_, and _secondToFirst_.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the caller graph for this function:

◆ end()

template<typename T1, typename T2>

const BijectionImplementation< T1, T2, true >::iterator & gum::BijectionImplementation< T1, T2 >::end ( ) const

noexcept

Returns the unsafe iterator at the end of the gum::Bijection.

Unsafe iterators are a little bit faster than safe ones. But this speed is at the expense of safety: if you point to an element that is deleted, then try to access it or trying to operate a ++ will most certainly result in a segfault. So, Unsafe iterators should only be used to parse gum::Bijection where no element is ever deleted. If unsure, prefer using safe iterators.

Note that the notion of a beginning/end of a gum::Bijection is rather fuzzy. What is important here is that for an instance bij of this class:

for(iterator iter = bij.begin(); iter != bij.end(); ++iter) {
  // loops will parse all the associations
}

Definition at line 195 of file bijection_tpl.h.

                                                                 {
    return *(reinterpret_cast< const BijectionIterator< T1, T2 >* >(_Bijection_end_));
  }

References BijectionIterator< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), and toString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endSafe()

template<typename T1, typename T2>

const BijectionImplementation< T1, T2, true >::iterator_safe & gum::BijectionImplementation< T1, T2 >::endSafe ( ) const

noexcept

Returns the safe iterator at the end of the gum::Bijection.

Safe iterators are slightly slower than unsafe iterators. However, they guarantee that no segmentation fault can ever occur when trying to access the element they point to or when applying a ++ operator. When no element of the gum::Bijection is to be deleted during the parsing of the gum::Bijection (as for instance when you parse the gum::Bijection to display its content), prefer using the unsafe iterators, which are a little bit faster and cannot, in this case, produce segfaults.

Note that the notion of a beginning/end of a gum::Bijection is rather fuzzy. What is important here is that for an instance bij of this class:

for (iterator iter = bij.beginSafe(); iter != bij.endSafe(); ++iter) {
  // loops will parse all the associations
}

Definition at line 223 of file bijection_tpl.h.

                                                                     {
    return *(reinterpret_cast< const BijectionIteratorSafe< T1, T2 >* >(_Bijection_end_safe_));
  }

References BijectionIteratorSafe< T1, T2 >.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseFirst()

template<typename T1, typename T2, bool Gen>

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

Erases an association containing the given first element.

If the element cannot be found, nothing is done. In particular, no exception is raised.

Parameters

first The first element of a pair in the gum::Bijection.

Definition at line 412 of file bijection_tpl.h.

                                                                         {
    if (auto ptr = _firstToSecond_.tryGet(first)) {
      _secondToFirst_.erase(**ptr);
      _firstToSecond_.erase(first);
    }
  }

References _firstToSecond_, _secondToFirst_, and first().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), gum::prm::gspan::Pattern::_not_rec_(), and gum::prm::gspan::Pattern::_rec_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseSecond()

template<typename T1, typename T2, bool Gen>

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

Erases an association containing the given second element.

If the element cannot be found, nothing is done. In particular, no exception is raised.

Parameters

second The second element of a pair in the gum::Bijection.

Definition at line 421 of file bijection_tpl.h.

                                                                           {
    if (auto ptr = _secondToFirst_.tryGet(second)) {
      _firstToSecond_.erase(**ptr);
      _secondToFirst_.erase(second);
    }
  }

References _secondToFirst_, and second().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ existsFirst() [1/2]

template<typename T1, typename T2, bool Gen>

template<typename K>

bool gum::BijectionImplementation< T1, T2, Gen >::existsFirst ( const K & first ) const

Heterogeneous overload: accepts any type convertible to string_view when T1=std::string.

Definition at line 264 of file bijection_tpl.h.

                                                                               {
    return _firstToSecond_.exists(first);
  }

References _firstToSecond_, existsFirst(), and first().

Here is the call graph for this function:

◆ existsFirst() [2/2]

template<typename T1, typename T2, bool Gen>

bool gum::BijectionImplementation< T1, T2, Gen >::existsFirst ( const T1 & first ) const

Returns true if first is the first element in a pair in the gum::Bijection.

Parameters

first The element tested for existence.

Returns: Returns true if first is in the first element in a pair in the gum::Bijection.

Definition at line 256 of file bijection_tpl.h.

                                                                                {
    return _firstToSecond_.exists(first);
  }

Referenced by _insert_(), _insert_(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), gum::prm::gspan::Pattern::_not_rec_(), gum::prm::gspan::Pattern::_rec_(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::copy(), and existsFirst().

Here is the caller graph for this function:

◆ existsSecond()

template<typename T1, typename T2, bool Gen>

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

Returns true if second is the second element in a pair in the gum::Bijection.

Parameters

second The element tested for existence.

Returns: Returns true if second is in the second element in a pair in the gum::Bijection.

Definition at line 270 of file bijection_tpl.h.

                                                                                  {
    return _secondToFirst_.exists(second);
  }

References _secondToFirst_, and second().

Referenced by _insert_(), _insert_(), and gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ first()

template<typename T1, typename T2, bool Gen>

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

Returns the first value of a pair given its second value.

Parameters

second The second value of a pair in the gum::Bijection.

Returns: Returns the first value of a pair given its second value.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 236 of file bijection_tpl.h.

                                                                                {
    return *(_secondToFirst_[second]);
  }

References _secondToFirst_, and second().

Referenced by _insert_(), _insert_(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), gum::prm::gspan::Pattern::_not_rec_(), gum::prm::gspan::Pattern::_rec_(), gum::prm::StructuredInference< GUM_SCALAR >::_translatePotSet_(), eraseFirst(), existsFirst(), insert(), insert(), second(), second(), secondWithDefault(), toString(), trySecond(), and trySecond().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ firstWithDefault()

template<typename T1, typename T2, bool Gen>

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

Returns the first value of a pair given its second value or default_val if second is unfound.

Parameters

second	The second value of a pair in the gum::Bijection.
default_val	The default value returned if second is not in the gum::Bijection.

Returns: Returns the first value of a pair given its second value or default_val if second is not in the bjection.

Definition at line 361 of file bijection_tpl.h.

                                                                                          {
    if (auto ptr = tryFirst(second)) return *ptr;
    return _insert_(val, second)->first;
  }

References _insert_(), second(), and tryFirst().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert() [1/2]

template<typename T1, typename T2, bool Gen>

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

Inserts a new association in the gum::Bijection.

The values are added by copy.

Parameters

first	The first element of the pair to insert.
second	The second element of the pair to insert.

Exceptions

DuplicateElement Raised if the association already exists.

Definition at line 378 of file bijection_tpl.h.

                                                                                       {
    _insert_(first, second);
  }

References _insert_(), first(), and second().

Referenced by BijectionImplementation(), gum::prm::PRMSlotChain< GUM_SCALAR >::_copyLastElt_(), gum::prm::gspan::Pattern::_expandCodeIsMinimal_(), gum::prm::PRMSystem< GUM_SCALAR >::_groundTensor_(), gum::prm::PRMSystem< double >::_groundTensor_(), gum::prm::PRMClass< GUM_SCALAR >::_inheritClass_(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), gum::prm::gspan::Pattern::_not_rec_(), gum::prm::gspan::Pattern::_rec_(), gum::prm::GSpan< GUM_SCALAR >::_sortNodesAndEdges_(), gum::prm::StructuredInference< GUM_SCALAR >::_translatePotSet_(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::copy(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), gum::InfluenceDiagram< GUM_SCALAR >::operator==(), and gum::TreeOperatorStrategy< GUM_ELEMENT >::regress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert() [2/2]

template<typename T1, typename T2, bool Gen>

void gum::BijectionImplementation< T1, T2, Gen >::insert	(	T1 &&	first,
		T2 &&	second )

Inserts a new association in the gum::Bijection.

The values are moved in the gum::Bijection.

Parameters

first	The first element of the pair to insert.
second	The second element of the pair to insert.

Exceptions

DuplicateElement Raised if the association already exists.

Definition at line 384 of file bijection_tpl.h.

                                                                             {
    _insert_(std::move(first), std::move(second));
  }

References _insert_(), first(), and second().

Here is the call graph for this function:

◆ operator=() [1/2]

template<typename T1, typename T2, bool Gen>

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

private

Move operator.

Parameters

toCopy Bijection to move

Returns: Returns the moved gum::Bijection in which the move was made.

Definition at line 163 of file bijection_tpl.h.

                                                     {
    // avoid self assignment
    if (this != &from) {
      clear();
      _firstToSecond_ = std::move(from._firstToSecond_);
      _secondToFirst_ = std::move(from._secondToFirst_);
    }
 
    // note that  _iter_end_ is actually a constant, whatever we add/remove
    // to/from  _firstToSecond_. As a consequence, it need not be updated
    // after  _copy_
    return *this;
  }

References BijectionImplementation, _firstToSecond_, _secondToFirst_, and clear().

Here is the call graph for this function:

◆ operator=() [2/2]

template<typename T1, typename T2, bool Gen>

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

private

Copy operator.

Parameters

toCopy Bijection to copy.

Returns: Returns the gum::Bijection in which the copy was made.

Definition at line 147 of file bijection_tpl.h.

                                                            {
    // avoid self assignment
    if (this != &toCopy) {
      clear();
      _copy_(toCopy._firstToSecond_);
    }
 
    // note that  _iter_end_ is actually a constant, whatever we add/remove
    // to/from  _firstToSecond_. As a consequence, it need not be updated
    // after  _copy_
    return *this;
  }

References BijectionImplementation, _copy_(), _firstToSecond_, and clear().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), gum::Bijection< T1, T2 >::operator=(), and gum::Bijection< T1, T2 >::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resize()

template<typename T1, typename T2>

void gum::BijectionImplementation< T1, T2 >::resize ( Size new_size )

Manually resize the gum::Bijection.

See gum::HashTable::resize(gum::Size)

Parameters

new_size The gum::Bijection new size.

Definition at line 436 of file bijection_tpl.h.

                                                                   {
    _firstToSecond_.resize(new_size);
    _secondToFirst_.resize(new_size);
  }

References _firstToSecond_, and _secondToFirst_.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the caller graph for this function:

◆ resizePolicy()

template<typename T1, typename T2>

bool gum::BijectionImplementation< T1, T2 >::resizePolicy ( ) const

noexcept

Returns true if the resize policy is automatic.

See gum::HashTable::resizePolicy().

Returns: Returns true if the resize policy is automatic.

Definition at line 450 of file bijection_tpl.h.

                                                                           {
    return _firstToSecond_.resizePolicy();
  }

References _firstToSecond_.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the caller graph for this function:

◆ second() [1/2]

template<typename T1, typename T2, bool Gen>

template<typename K>

const T2 & gum::BijectionImplementation< T1, T2, Gen >::second ( const K & first ) const

Heterogeneous overload: accepts any type convertible to string_view when T1=std::string.

Definition at line 250 of file bijection_tpl.h.

                                                                               {
    return *(_firstToSecond_[first]);
  }

References _firstToSecond_, first(), and second().

Here is the call graph for this function:

◆ second() [2/2]

template<typename T1, typename T2, bool Gen>

const T2 & gum::BijectionImplementation< T1, T2, Gen >::second ( const T1 & first ) const

Returns the second value of a pair given its first value.

Parameters

first The first value of a pair in the gum::Bijection.

Returns: Returns the second value of a pair given its first value.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 242 of file bijection_tpl.h.

                                                                                {
    return *(_firstToSecond_[first]);
  }

References _firstToSecond_, and first().

Referenced by _insert_(), _insert_(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), gum::prm::gspan::Pattern::_not_rec_(), gum::prm::gspan::Pattern::_rec_(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copyCpf(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::copyCpf(), gum::prm::copyTensor(), eraseSecond(), existsSecond(), first(), firstWithDefault(), insert(), insert(), gum::MultiDimFunctionGraph< double >::node(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), gum::InfluenceDiagram< GUM_SCALAR >::operator==(), second(), and tryFirst().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ secondWithDefault()

template<typename T1, typename T2, bool Gen>

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

Returns the second value of a pair given its first value or default_val if first is unfound.

Parameters

second	The second value of a pair in the gum::Bijection.
default_val	The default value returned if first is not in the gum::Bijection.

Returns: Returns the second value of a pair given its first value or default_val if first is not in the bjection.

Definition at line 370 of file bijection_tpl.h.

                                                                                           {
    if (auto ptr = trySecond(first)) return *ptr;
    return *(_insert_(first, val)->second);
  }

References first().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setResizePolicy()

template<typename T1, typename T2>

void gum::BijectionImplementation< T1, T2 >::setResizePolicy ( const bool new_policy )

noexcept

Change the gum::Bijection resizing policy.

See gum::HashTable::setResizePolicy( const bool );

Parameters

new_policy If true, the gum::Bijection will resize automatically.

Definition at line 443 of file bijection_tpl.h.

                                                                                             {
    _firstToSecond_.setResizePolicy(new_policy);
    _secondToFirst_.setResizePolicy(new_policy);
  }

References _firstToSecond_, and _secondToFirst_.

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the caller graph for this function:

◆ size()

template<typename T1, typename T2>

Size gum::BijectionImplementation< T1, T2 >::size ( ) const

noexcept

Returns the number of associations stored within the gum::Bijection.

Returns: Returns the number of associations stored within the gum::Bijection.

Definition at line 405 of file bijection_tpl.h.

                                                                   {
    GUM_ASSERT(_firstToSecond_.size() == _secondToFirst_.size());
    return _firstToSecond_.size();
  }

Referenced by BijectionImplementation(), BijectionImplementation(), and gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_().

Here is the caller graph for this function:

◆ toString()

template<typename T1, typename T2>

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

Returns a friendly representatin of the gum::Bijection.

Returns: Returns a friendly representatin of the gum::Bijection.

Definition at line 456 of file bijection_tpl.h.

                                                                   {
    std::stringstream stream;
    stream << "{ ";
    bool first = true;
 
    for (iterator iter = begin(); iter != end(); ++iter) {
      if (!first) stream << ", ";
      else first = false;
 
      stream << '(' << iter.first() << " <-> " << iter.second() << ')';
    }
 
    stream << " }";
    return stream.str();
  }

References begin(), end(), and first().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), and gum::operator<<().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tryFirst()

template<typename T1, typename T2, bool Gen>

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

Returns a pointer to the first value associated with the given second value, or nullptr if not found.

Parameters

second The second value to look up.

Returns: A pointer to the first value, or nullptr if not found.

Definition at line 277 of file bijection_tpl.h.

                                                                             {
    auto ptr = _secondToFirst_.tryGet(second);
    if (!ptr) return {};
    return optional_ref< const T1 >(**ptr);
  }

References second().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), and firstWithDefault().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ trySecond() [1/2]

template<typename T1, typename T2, bool Gen>

template<typename K>

optional_ref< const T2 > gum::BijectionImplementation< T1, T2, Gen >::trySecond ( const K & first ) const

Heterogeneous overload: accepts any type convertible to string_view when T1=std::string.

Definition at line 296 of file bijection_tpl.h.

                                                                                                 {
    auto ptr = _firstToSecond_.tryGet(first);
    if (!ptr) return {};
    return optional_ref< const T2 >(**ptr);
  }

References _firstToSecond_, first(), and trySecond().

Here is the call graph for this function:

◆ trySecond() [2/2]

template<typename T1, typename T2, bool Gen>

optional_ref< const T2 > gum::BijectionImplementation< T1, T2, Gen >::trySecond ( const T1 & first ) const

Returns an optional reference to the second value associated with the given first value, or empty if not found.

Parameters

first The first value to look up.

Returns: An optional_ref to the second value, or empty if not found.

Definition at line 286 of file bijection_tpl.h.

                                                                             {
    auto ptr = _firstToSecond_.tryGet(first);
    if (!ptr) return {};
    return optional_ref< const T2 >(**ptr);
  }

References _firstToSecond_, and first().

Referenced by gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), and trySecond().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BijectionImplementation

template<typename T1, typename T2, bool Gen>

template<typename TT1, typename TT2, bool>

friend class BijectionImplementation

friend

a friend to speed-up accesses

Definition at line 607 of file bijection.h.

Referenced by BijectionImplementation(), BijectionImplementation(), BijectionImplementation(), BijectionImplementation(), ~BijectionImplementation(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::_insert_(), operator=(), and operator=().

◆ Bijection< T1, T2 >

template<typename T1, typename T2, bool Gen>

friend class Bijection< T1, T2 >

friend

a friend to speed-up accesses

Definition at line 590 of file bijection.h.

Referenced by gum::Bijection< const DiscreteVariable *, const DiscreteVariable * >::Bijection(), gum::Bijection< const DiscreteVariable *, const DiscreteVariable * >::Bijection(), gum::Bijection< const DiscreteVariable *, const DiscreteVariable * >::operator=(), and gum::Bijection< const DiscreteVariable *, const DiscreteVariable * >::operator=().

◆ BijectionIterator< T1, T2 >

template<typename T1, typename T2, bool Gen>

friend class BijectionIterator< T1, T2 >

friend

a friend to speed-up accesses

Definition at line 590 of file bijection.h.

Referenced by begin(), cbegin(), cend(), and end().

◆ BijectionIteratorSafe< T1, T2 >

template<typename T1, typename T2, bool Gen>

friend class BijectionIteratorSafe< T1, T2 >

friend

a friend to speed-up accesses

Definition at line 590 of file bijection.h.

Referenced by beginSafe(), cbeginSafe(), cendSafe(), and endSafe().

Member Data Documentation

◆ _firstToSecond_

template<typename T1, typename T2, bool Gen>

HashTable12 gum::BijectionImplementation< T1, T2, Gen >::_firstToSecond_

private

The gum::HashTable associating T2 objects to T1 objects.

Definition at line 616 of file bijection.h.

Referenced by BijectionImplementation(), BijectionImplementation(), BijectionImplementation(), BijectionImplementation(), _copy_(), _insert_(), _insert_(), capacity(), clear(), empty(), eraseFirst(), existsFirst(), operator=(), operator=(), resize(), resizePolicy(), second(), second(), setResizePolicy(), gum::BijectionImplementation< const gum::DiscreteVariable *, const gum::DiscreteVariable *, std::is_scalar< const gum::DiscreteVariable * >::value &&std::is_scalar< const gum::DiscreteVariable * >::value >::size(), trySecond(), and trySecond().

◆ _secondToFirst_

template<typename T1, typename T2, bool Gen>

HashTable21 gum::BijectionImplementation< T1, T2, Gen >::_secondToFirst_

private

The gum::HashTable associating T1 objects to T2 objects.

Definition at line 619 of file bijection.h.

Referenced by BijectionImplementation(), BijectionImplementation(), BijectionImplementation(), BijectionImplementation(), _copy_(), _insert_(), _insert_(), clear(), empty(), eraseFirst(), eraseSecond(), existsSecond(), first(), operator=(), resize(), and setResizePolicy().

The documentation for this class was generated from the following files:

agrum/base/core/bijection.h
agrum/base/core/bijection_tpl.h

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ const_iterator_safe

◆ difference_type

◆ HashTable12

◆ HashTable21

◆ iterator

◆ iterator_safe

◆ size_type

◆ type1_const_pointer

◆ type1_const_reference

◆ type1_pointer

◆ type1_reference

◆ type1_type

◆ type2_const_pointer

◆ type2_const_reference

◆ type2_pointer

◆ type2_reference

◆ type2_type

Constructor & Destructor Documentation

◆ BijectionImplementation() [1/6]

◆ BijectionImplementation() [2/6]

◆ BijectionImplementation() [3/6]

◆ BijectionImplementation() [4/6]

◆ ~BijectionImplementation()

◆ BijectionImplementation() [5/6]

◆ BijectionImplementation() [6/6]

Member Function Documentation

◆ _copy_()

◆ _insert_() [1/2]

◆ _insert_() [2/2]

◆ begin()

◆ beginSafe()

◆ capacity()

◆ cbegin()

◆ cbeginSafe()

◆ cend()

◆ cendSafe()

◆ clear()

◆ emplace()

◆ empty()

◆ end()

◆ endSafe()

◆ eraseFirst()

◆ eraseSecond()

◆ existsFirst() [1/2]

◆ existsFirst() [2/2]

◆ existsSecond()

◆ first()

◆ firstWithDefault()

◆ insert() [1/2]

◆ insert() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ resize()

◆ resizePolicy()

◆ second() [1/2]

◆ second() [2/2]

◆ secondWithDefault()

◆ setResizePolicy()

◆ size()

◆ toString()

◆ tryFirst()

◆ trySecond() [1/2]

◆ trySecond() [2/2]

Friends And Related Symbol Documentation

◆ BijectionImplementation

◆ Bijection< T1, T2 >

◆ BijectionIterator< T1, T2 >

◆ BijectionIteratorSafe< T1, T2 >

Member Data Documentation

◆ _firstToSecond_

◆ _secondToFirst_