aGrUM  0.13.2
gum::Bijection< T1, T2, Alloc > Class Template Reference

Set of pairs of elements with fast search for both elements. More...

#include <agrum/core/bijection.h>

+ Inheritance diagram for gum::Bijection< T1, T2, Alloc >:
+ Collaboration diagram for gum::Bijection< T1, T2, Alloc >:

Public Member Functions

template<typename OtherAlloc >
INLINE Bijection (const Bijection< T1, T2, OtherAlloc > &toCopy)
 
template<typename OtherAlloc >
INLINE Bijection< T1, T2, Alloc > & operator= (const Bijection< T1, T2, OtherAlloc > &toCopy)
 
Constructors/destructors
 Bijection (Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
 Default constructor: creates a gum::Bijection without any association. More...
 
 Bijection (std::initializer_list< std::pair< T1, T2 > > list)
 Initializer list constructor. More...
 
 Bijection (const Bijection< T1, T2, Alloc > &toCopy)
 Copy constructor. More...
 
template<typename OtherAlloc >
 Bijection (const Bijection< T1, T2, OtherAlloc > &toCopy)
 Generalized copy constructor. More...
 
 Bijection (Bijection< T1, T2, Alloc > &&from) noexcept
 Move constructor. More...
 
 ~Bijection ()
 Class destructor. More...
 
Operators
Bijection< T1, T2, Alloc > & operator= (const Bijection< T1, T2, Alloc > &toCopy)
 Copy operator. More...
 
template<typename OtherAlloc >
Bijection< T1, T2, Alloc > & operator= (const Bijection< T1, T2, OtherAlloc > &toCopy)
 Generalized copy operator. More...
 
Bijection< T1, T2, Alloc > & operator= (Bijection< T1, T2, Alloc > &&bij)
 Move operator. More...
 
Accessors / Modifiers
const T1 & first (const T2 &second) const
 Returns the first value of a pair given its second value. More...
 
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. More...
 
const T2 & second (const T1 &first) const
 Returns the second value of a pair given its first value. More...
 
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. More...
 
bool existsFirst (const T1 &first) const
 Returns true if first is the first element in a pair in the gum::Bijection. More...
 
bool existsSecond (const T2 &second) const
 Returns true if second is the second element in a pair in the gum::Bijection. More...
 
void insert (const T1 &first, const T2 &second)
 Inserts a new association in the gum::Bijection. More...
 
void insert (T1 &&first, T2 &&second)
 Inserts a new association in the gum::Bijection. More...
 
void emplace (Args &&...args)
 Emplace a new element in the gum::Bijection. More...
 
void clear ()
 Removes all the associations from the gum::Bijection. More...
 
bool empty () const noexcept
 Returns true if the gum::Bijection doesn't contain any association. More...
 
Size size () const noexcept
 Returns the number of associations stored within the gum::Bijection. More...
 
void eraseFirst (const T1 &first)
 Erases an association containing the given first element. More...
 
void eraseSecond (const T2 &second)
 Erases an association containing the given second element. More...
 
std::string toString () const
 Returns a friendly representatin of the gum::Bijection. More...
 
Fine tuning
Size capacity () const noexcept
 Returns the number of hashtables slots used. More...
 
void resize (Size new_size)
 Manually resize the gum::Bijection. More...
 
void setResizePolicy (const bool new_policy) noexcept
 Change the gum::Bijection resizing policy. More...
 
bool resizePolicy () const noexcept
 Returns true if the resize policy is automatic. More...
 

Public Types

using Implementation = BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >
 The Implementation of this gum::Bijection. More...
 
using type1_type = T1
 types for STL compliance More...
 
using type1_reference = T1 &
 types for STL compliance More...
 
using type1_const_reference = const T1 &
 types for STL compliance More...
 
using type1_pointer = T1 *
 types for STL compliance More...
 
using type1_const_pointer = const T1 *
 types for STL compliance More...
 
using type2_type = T2
 types for STL compliance More...
 
using type2_reference = T2 &
 types for STL compliance More...
 
using type2_const_reference = const T2 &
 types for STL compliance More...
 
using type2_pointer = T2 *
 types for STL compliance More...
 
using type2_const_pointer = const T2 *
 types for STL compliance More...
 
using size_type = std::size_t
 types for STL compliance More...
 
using difference_type = std::ptrdiff_t
 types for STL compliance More...
 
using allocator_type = Alloc
 types for STL compliance More...
 
using iterator = BijectionIterator< T1, T2 >
 types for STL compliance More...
 
using const_iterator = BijectionIterator< T1, T2 >
 types for STL compliance More...
 
using iterator_safe = BijectionIteratorSafe< T1, T2 >
 types for STL compliance More...
 
using const_iterator_safe = BijectionIteratorSafe< T1, T2 >
 types for STL compliance More...
 
using allocator1_type = typename Alloc::template rebind< T1 * >::other
 types for STL compliance More...
 
using allocator2_type = typename Alloc::template rebind< T2 * >::other
 types for STL compliance More...
 
using allocator12_type = typename Alloc::template rebind< std::pair< T1, T2 * > >::other
 types for STL compliance More...
 
using allocator21_type = typename Alloc::template rebind< std::pair< T2, T1 * > >::other
 types for STL compliance More...
 

Iterators

iterator begin () const
 Returns the unsafe iterator at the beginning of the gum::Bijection. More...
 
const_iterator cbegin () const
 Returns the constant unsafe iterator at the beginning of the gum::Bjection. More...
 
const iteratorend () const noexcept
 Returns the unsafe iterator at the end of the gum::Bijection. More...
 
const const_iteratorcend () const noexcept
 Returns the constant iterator at the end of the gum::Bijection. More...
 
iterator_safe beginSafe () const
 Returns the safe iterator at the beginning of the gum::Bijection. More...
 
const_iterator_safe cbeginSafe () const
 Returns the constant safe iterator at the begining of the gum::Bijection. More...
 
const iterator_safeendSafe () const noexcept
 Returns the safe iterator at the end of the gum::Bijection. More...
 
const const_iterator_safecendSafe () const noexcept
 Returns the constant safe iterator at the end of the gum::Bijection. More...
 
static const iterator_safeendSafe4Statics ()
 Returns the safe end iterator for other classes' statics. More...
 
static const iteratorend4Statics ()
 Returns the unsafe end iterator for other classes' statics. More...
 

Detailed Description

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
class gum::Bijection< T1, T2, Alloc >

Set of pairs of elements with fast search for both elements.

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
T1The first type of elements in the gum::Bjection.
T2The second type of elements in the gum::Bjection.
AllocThe allocator used for allocating memory.

Definition at line 1803 of file bijection.h.

Member Typedef Documentation

using gum::BijectionImplementation< T1, T2, Alloc, Gen >::allocator12_type = typename Alloc::template rebind< std::pair< T1, T2* > >::other
inherited

types for STL compliance

Definition at line 105 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::allocator1_type = typename Alloc::template rebind< T1* >::other

types for STL compliance

Definition at line 1830 of file bijection.h.

using gum::BijectionImplementation< T1, T2, Alloc, Gen >::allocator21_type = typename Alloc::template rebind< std::pair< T2, T1* > >::other
inherited

types for STL compliance

Definition at line 107 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::allocator2_type = typename Alloc::template rebind< T2* >::other

types for STL compliance

Definition at line 1831 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::allocator_type = Alloc

types for STL compliance

Definition at line 1824 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::const_iterator = BijectionIterator< T1, T2 >

types for STL compliance

Definition at line 1826 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::const_iterator_safe = BijectionIteratorSafe< T1, T2 >

types for STL compliance

Definition at line 1828 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::difference_type = std::ptrdiff_t

types for STL compliance

Definition at line 1823 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::Implementation = BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >

The Implementation of this gum::Bijection.

Definition at line 1840 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::iterator = BijectionIterator< T1, T2 >

types for STL compliance

Definition at line 1825 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::iterator_safe = BijectionIteratorSafe< T1, T2 >

types for STL compliance

Definition at line 1827 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::size_type = std::size_t

types for STL compliance

Definition at line 1822 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type1_const_pointer = const T1*

types for STL compliance

Definition at line 1816 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type1_const_reference = const T1&

types for STL compliance

Definition at line 1814 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type1_pointer = T1*

types for STL compliance

Definition at line 1815 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type1_reference = T1&

types for STL compliance

Definition at line 1813 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type1_type = T1

types for STL compliance

Definition at line 1812 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type2_const_pointer = const T2*

types for STL compliance

Definition at line 1821 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type2_const_reference = const T2&

types for STL compliance

Definition at line 1819 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type2_pointer = T2*

types for STL compliance

Definition at line 1820 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type2_reference = T2&

types for STL compliance

Definition at line 1818 of file bijection.h.

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
using gum::Bijection< T1, T2, Alloc >::type2_type = T2

types for STL compliance

Definition at line 1817 of file bijection.h.

Constructor & Destructor Documentation

template<typename T1 , typename T2 , typename Alloc >
INLINE gum::Bijection< T1, T2, Alloc >::Bijection ( Size  size = HashTableConst::default_size,
bool  resize_policy = HashTableConst::default_resize_policy 
)

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

Parameters
sizeThe gum::Bijection starting size.
resize_policyIf tru, the gum::Bijection will be automatically resized.

Definition at line 1150 of file bijection_tpl.h.

1150  :
1152  T2,
1153  Alloc,
1154  std::is_scalar< T1 >::value
1155  && std::is_scalar< T2 >::value >(size,
1156  resize_policy) {
1157  GUM_CONSTRUCTOR(Bijection);
1158  }
Size size() const noexcept
Returns the number of associations stored within the gum::Bijection.
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.
template<typename T1, typename T2, typename Alloc >
INLINE gum::Bijection< T1, T2, Alloc >::Bijection ( std::initializer_list< std::pair< T1, T2 > >  list)

Initializer list constructor.

Parameters
listThe initialisation list.

Definition at line 1162 of file bijection_tpl.h.

1163  :
1165  T2,
1166  Alloc,
1167  std::is_scalar< T1 >::value
1168  && std::is_scalar< T2 >::value >(list) {
1169  GUM_CONSTRUCTOR(Bijection);
1170  }
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.
template<typename T1, typename T2, typename Alloc>
INLINE gum::Bijection< T1, T2, Alloc >::Bijection ( const Bijection< T1, T2, Alloc > &  toCopy)

Copy constructor.

Parameters
toCopyThe gum::Bijection to copy.

Definition at line 1174 of file bijection_tpl.h.

1175  :
1177  T2,
1178  Alloc,
1179  std::is_scalar< T1 >::value
1180  && std::is_scalar< T2 >::value >(toCopy) {
1181  GUM_CONS_CPY(Bijection);
1182  }
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.
template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
template<typename OtherAlloc >
gum::Bijection< T1, T2, Alloc >::Bijection ( const Bijection< T1, T2, OtherAlloc > &  toCopy)

Generalized copy constructor.

Parameters
toCopyThe gum::Bijection to copy.
Template Parameters
Thegum::Bijection to copy allocator's type.
template<typename T1, typename T2, typename Alloc>
INLINE gum::Bijection< T1, T2, Alloc >::Bijection ( Bijection< T1, T2, Alloc > &&  from)
noexcept

Move constructor.

Parameters
fromThe gum::Bijection to move from.

Definition at line 1199 of file bijection_tpl.h.

1200  :
1202  T2,
1203  Alloc,
1204  std::is_scalar< T1 >::value
1205  && std::is_scalar< T2 >::value >(
1206  std::move(from)) {
1207  GUM_CONS_MOV(Bijection);
1208  }
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.
template<typename T1 , typename T2 , typename Alloc >
INLINE gum::Bijection< T1, T2, Alloc >::~Bijection ( )

Class destructor.

Definition at line 1212 of file bijection_tpl.h.

References gum::Bijection< T1, T2, Alloc >::operator=().

1212  {
1213  GUM_DESTRUCTOR(Bijection);
1214  }
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.

+ Here is the call graph for this function:

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
template<typename OtherAlloc >
INLINE gum::Bijection< T1, T2, Alloc >::Bijection ( const Bijection< T1, T2, OtherAlloc > &  toCopy)

Definition at line 1187 of file bijection_tpl.h.

1188  :
1190  T2,
1191  Alloc,
1192  std::is_scalar< T1 >::value
1193  && std::is_scalar< T2 >::value >(toCopy) {
1194  GUM_CONS_CPY(Bijection);
1195  }
Bijection(Size size=HashTableConst::default_size, bool resize_policy=HashTableConst::default_resize_policy)
Default constructor: creates a gum::Bijection without any association.

Member Function Documentation

iterator gum::BijectionImplementation< T1, T2, Alloc, Gen >::begin ( ) const
inherited

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.
}
iterator_safe gum::BijectionImplementation< T1, T2, Alloc, Gen >::beginSafe ( ) const
inherited

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
}
Size gum::BijectionImplementation< T1, T2, Alloc, Gen >::capacity ( ) const
noexceptinherited

Returns the number of hashtables slots used.

Returns
Returns the number of hashtables slots used.
const_iterator gum::BijectionImplementation< T1, T2, Alloc, Gen >::cbegin ( ) const
inherited

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
}

Referenced by gum::BijectionIterator< T1, T2 >::BijectionIterator().

const_iterator_safe gum::BijectionImplementation< T1, T2, Alloc, Gen >::cbeginSafe ( ) const
inherited

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
}

Referenced by gum::BijectionIteratorSafe< T1, T2 >::BijectionIteratorSafe().

const const_iterator& gum::BijectionImplementation< T1, T2, Alloc, Gen >::cend ( ) const
noexceptinherited

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
}
const const_iterator_safe& gum::BijectionImplementation< T1, T2, Alloc, Gen >::cendSafe ( ) const
noexceptinherited

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
}
void gum::BijectionImplementation< T1, T2, Alloc, Gen >::clear ( )
inherited

Removes all the associations from the gum::Bijection.

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

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
argsthe arguments passed to the constructor
Exceptions
DuplicateElementexception is thrown if the association already exists
bool gum::BijectionImplementation< T1, T2, Alloc, Gen >::empty ( ) const
noexceptinherited

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

Returns
Returns true if the gum::Bijection doesn't contain any association.
const iterator& gum::BijectionImplementation< T1, T2, Alloc, Gen >::end ( ) const
noexceptinherited

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
}
static const iterator& gum::BijectionImplementation< T1, T2, Alloc, Gen >::end4Statics ( )
staticinherited

Returns the unsafe end iterator for other classes' statics.

To reduce the gum::Bijection memory consumption (which are heavily used in aGrUM) while allowing fast for loops, end iterators are created just once as a static member of a non-template gum::Bijection. While this scheme is efficient and it works quite effectively, it has a drawback: other classes with static members using the BijectionImplementation::end() iterator may fail to work due to the well known "static initialization order fiasco" (see Marshall Cline's C++ FAQ for more details about this C++ feature).

So what is the problem? Consider a class, say X, containing a gum::Bijection that stores all its elements in a convenient way. To reduce memory consumption, X::end iterator is a static member that is initialized with a gum::Bijection::end iterator. If the compiler decides to initialize X::end before initializing gum::Bijection::end, then X::end will be in an incoherent state.

Unfortunately, we cannot know for sure in which order static members will be initialized (the order is a compiler's decision). Hence, we shall enfore the fact that gum::Bijection::end is initialized before X::end. Using method gum::Bijection::end4Statics will ensure this fact: it uses the C++ "construct on first use" idiom (see the C++ FAQ) that ensures that the order fiasco is avoided. More precisely, end4Statics uses a global variable that is the very end iterator used by all gum::Bijection. Now, this induces a small overhead. So, we also provide a gum::Bijection::end() method that returns the gum::Bijection::end iterator without this small overhead, but assuming that function end4Statics has already been called once (which is always the case) when a gum::Bijection has been created.

So, to summarize: when initializing static members use end4Statics() and in all the other cases, use end().

const iterator_safe& gum::BijectionImplementation< T1, T2, Alloc, Gen >::endSafe ( ) const
noexceptinherited

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
}
static const iterator_safe& gum::BijectionImplementation< T1, T2, Alloc, Gen >::endSafe4Statics ( )
staticinherited

Returns the safe end iterator for other classes' statics.

To reduce the gum::Bijection memory consumption (which are heavily used in aGrUM) while allowing fast for loops, end iterators are created just once as a static member of a non-template gum::Bijection. While this scheme is efficient and it works quite effectively, it has a drawback: other classes with static members using the BijectionImplementation::end() iterator may fail to work due to the well known "static initialization order fiasco" (see Marshall Cline's C++ FAQ for more details about this C++ feature).

So what is the problem? Consider a class, say X, containing a gum::Bijection that stores all its elements in a convenient way. To reduce memory consumption, X::end iterator is a static member that is initialized with a gum::Bijection::end iterator. If the compiler decides to initialize X::end before initializing gum::Bijection::end, then X::end will be in an incoherent state.

Unfortunately, we cannot know for sure in which order static members will be initialized (the order is a compiler's decision). Hence, we shall enfore the fact that gum::Bijection::end is initialized before X::end. Using method gum::Bijection::end4Statics will ensure this fact: it uses the C++ "construct on first use" idiom (see the C++ FAQ) that ensures that the order fiasco is avoided. More precisely, end4Statics uses a global variable that is the very end iterator used by all gum::Bijection. Now, this induces a small overhead. So, we also provide a gum::Bijection::end() method that returns the gum::Bijection::end iterator without this small overhead, but assuming that function end4Statics has already been called once (which is always the case) when a gum::Bijection has been created.

So, to summarize: when initializing static members use endSafe4Statics() and in all the other cases, use endSafe().

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

Erases an association containing the given first element.

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

Parameters
firstThe first element of a pair in the gum::Bijection.

Referenced by gum::prm::gspan::Pattern::__not_rec(), and gum::prm::gspan::Pattern::__rec().

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

Erases an association containing the given second element.

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

Parameters
secondThe second element of a pair in the gum::Bijection.
bool gum::BijectionImplementation< T1, T2, Alloc, Gen >::existsFirst ( const T1 &  first) const
inherited
bool gum::BijectionImplementation< T1, T2, Alloc, Gen >::existsSecond ( const T2 &  second) const
inherited

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

Parameters
secondThe element tested for existence.
Returns
Returns true if second is in the second element in a pair in the gum::Bijection.
const T1& gum::BijectionImplementation< T1, T2, Alloc, Gen >::first ( const T2 &  second) const
inherited

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

Parameters
secondThe second value of a pair in the gum::Bijection.
Returns
Returns the first value of a pair given its second value.
Exceptions
NotFoundRaised if the element cannot be found.

Referenced by gum::prm::gspan::Pattern::__not_rec(), gum::prm::gspan::Pattern::__rec(), gum::prm::StructuredInference< GUM_SCALAR >::__translatePotSet(), and gum::MultiDimICIModel< GUM_SCALAR >::MultiDimICIModel().

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

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

Parameters
secondThe second value of a pair in the gum::Bijection.
default_valThe 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.
void gum::BijectionImplementation< T1, T2, Alloc, Gen >::insert ( T1 &&  first,
T2 &&  second 
)
inherited

Inserts a new association in the gum::Bijection.

The values are moved in the gum::Bijection.

Parameters
firstThe first element of the pair to insert.
secondThe second element of the pair to insert.
Exceptions
DuplicateElementRaised if the association already exists.
template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
template<typename OtherAlloc >
INLINE Bijection< T1, T2, Alloc >& gum::Bijection< T1, T2, Alloc >::operator= ( const Bijection< T1, T2, OtherAlloc > &  toCopy)

Definition at line 1228 of file bijection_tpl.h.

References gum::BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::operator=(), and gum::Bijection< T1, T2, Alloc >::operator=().

1228  {
1229  Implementation::operator=(toCopy);
1230  return *this;
1231  }
BijectionImplementation< T1, T2, Alloc, Gen > & operator=(const BijectionImplementation< T1, T2, Alloc, Gen > &toCopy)
Copy operator.

+ Here is the call graph for this function:

template<typename T1, typename T2, typename Alloc>
INLINE Bijection< T1, T2, Alloc > & gum::Bijection< T1, T2, Alloc >::operator= ( const Bijection< T1, T2, Alloc > &  toCopy)

Copy operator.

Parameters
toCopyThe gum::Bijection to copy.
Returns
Returns this gum::Bijection.

Definition at line 1219 of file bijection_tpl.h.

References gum::BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::operator=().

Referenced by gum::Bijection< T1, T2, Alloc >::operator=(), and gum::Bijection< T1, T2, Alloc >::~Bijection().

1219  {
1220  Implementation::operator=(toCopy);
1221  return *this;
1222  }
BijectionImplementation< T1, T2, Alloc, Gen > & operator=(const BijectionImplementation< T1, T2, Alloc, Gen > &toCopy)
Copy operator.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<typename T1, typename T2, typename Alloc = std::allocator< T2 >>
template<typename OtherAlloc >
Bijection< T1, T2, Alloc >& gum::Bijection< T1, T2, Alloc >::operator= ( const Bijection< T1, T2, OtherAlloc > &  toCopy)

Generalized copy operator.

Parameters
toCopyThe gum::Bijection to copy.
Template Parameters
OtherAllocThe gum::Bijection to copy allocator's type.
template<typename T1, typename T2, typename Alloc>
INLINE Bijection< T1, T2, Alloc > & gum::Bijection< T1, T2, Alloc >::operator= ( Bijection< T1, T2, Alloc > &&  bij)

Move operator.

Parameters
bijThe gum::Bijection to move from.

Definition at line 1236 of file bijection_tpl.h.

References gum::BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::operator=().

1236  {
1237  Implementation::operator=(std::move(bij));
1238  return *this;
1239  }
BijectionImplementation< T1, T2, Alloc, Gen > & operator=(const BijectionImplementation< T1, T2, Alloc, Gen > &toCopy)
Copy operator.

+ Here is the call graph for this function:

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

Manually resize the gum::Bijection.

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

Parameters
new_sizeThe gum::Bijection new size.
bool gum::BijectionImplementation< T1, T2, Alloc, Gen >::resizePolicy ( ) const
noexceptinherited

Returns true if the resize policy is automatic.

See gum::HashTable::resizePolicy().

Returns
Returns true if the resize policy is automatic.
const T2& gum::BijectionImplementation< T1, T2, Alloc, Gen >::second ( const T1 &  first) const
inherited
const T2& gum::BijectionImplementation< T1, T2, Alloc, Gen >::secondWithDefault ( const T1 &  second,
const T2 &  default_val 
) const
inherited

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

Parameters
secondThe second value of a pair in the gum::Bijection.
default_valThe 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.
void gum::BijectionImplementation< T1, T2, Alloc, Gen >::setResizePolicy ( const bool  new_policy)
noexceptinherited

Change the gum::Bijection resizing policy.

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

Parameters
new_policyIf true, the gum::Bijection will resize automatically.
Size gum::BijectionImplementation< T1, T2, Alloc, Gen >::size ( ) const
noexceptinherited

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

Returns
Returns the number of associations stored within the gum::Bijection.
std::string gum::BijectionImplementation< T1, T2, Alloc, Gen >::toString ( ) const
inherited

Returns a friendly representatin of the gum::Bijection.

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

Referenced by gum::operator<<().


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