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

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

#include <agrum/tools/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)
INLINE void	emplace (Args &&... args)
INLINE void	_copy_ (const HashTable< T1, T2 *, OtherAlloc > &f2s)
INLINE void	_copy_ (const HashTable< T1, T2, OtherAlloc > &f2s)
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 iterator &	end () const noexcept
	Returns the unsafe iterator at the end of the gum::Bijection. More...
const const_iterator &	cend () 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_safe &	endSafe () const noexcept
	Returns the safe iterator at the end of the gum::Bijection. More...
const const_iterator_safe &	cendSafe () const noexcept
	Returns the constant safe iterator at the end of the gum::Bijection. More...
static const iterator_safe &	endSafe4Statics ()
	Returns the safe end iterator for other classes' statics. More...
static const iterator &	end4Statics ()
	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

T1	The first type of elements in the gum::Bjection.
T2	The second type of elements in the gum::Bjection.
Alloc	The allocator used for allocating memory.

Definition at line 1786 of file bijection.h.

Member Typedef Documentation

allocator12_type

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.

allocator1_type

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 1812 of file bijection.h.

allocator21_type

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 106 of file bijection.h.

allocator2_type

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 1813 of file bijection.h.

allocator_type

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 1806 of file bijection.h.

const_iterator

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 1808 of file bijection.h.

const_iterator_safe

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 1810 of file bijection.h.

difference_type

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 1805 of file bijection.h.

Implementation

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 1821 of file bijection.h.

iterator

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 1807 of file bijection.h.

iterator_safe

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 1809 of file bijection.h.

size_type

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 1804 of file bijection.h.

type1_const_pointer

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 1798 of file bijection.h.

type1_const_reference

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 1796 of file bijection.h.

type1_pointer

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 1797 of file bijection.h.

type1_reference

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 1795 of file bijection.h.

type1_type

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 1794 of file bijection.h.

type2_const_pointer

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 1803 of file bijection.h.

type2_const_reference

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 1801 of file bijection.h.

type2_pointer

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 1802 of file bijection.h.

type2_reference

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 1800 of file bijection.h.

type2_type

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 1799 of file bijection.h.

Constructor & Destructor Documentation

Bijection() [1/6]

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

size	The gum::Bijection starting size.
resize_policy	If tru, the gum::Bijection will be automatically resized.

Definition at line 1105 of file bijection_tpl.h.

                                                                            :
      BijectionImplementation< T1,
                               T2,
                               Alloc,
                               std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >(
         size,
         resize_policy) {
    GUM_CONSTRUCTOR(Bijection);
  }

Bijection() [2/6]

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

list	The initialisation list.

Definition at line 1117 of file bijection_tpl.h.

                                                                                            :
      BijectionImplementation< T1,
                               T2,
                               Alloc,
                               std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >(list) {
    GUM_CONSTRUCTOR(Bijection);
  }

Bijection() [3/6]

template<typename T1, typename T2, typename Alloc>

INLINE gum::Bijection< T1, T2, Alloc >::Bijection

(

const Bijection< T1, T2, Alloc > &

toCopy

)

Copy constructor.

Parameters

toCopy

The gum::Bijection to copy.

Definition at line 1127 of file bijection_tpl.h.

                                                                                       :
      BijectionImplementation< T1,
                               T2,
                               Alloc,
                               std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >(
         toCopy) {
    GUM_CONS_CPY(Bijection);
  }

Bijection() [4/6]

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

toCopy

The gum::Bijection to copy.

Template Parameters

The	gum::Bijection to copy allocator's type.

Bijection() [5/6]

template<typename T1, typename T2, typename Alloc>

INLINE gum::Bijection< T1, T2, Alloc >::Bijection ( Bijection< T1, T2, Alloc > &&  from )

noexcept

Move constructor.

Parameters

from	The gum::Bijection to move from.

Definition at line 1150 of file bijection_tpl.h.

                                                                                         :
      BijectionImplementation< T1,
                               T2,
                               Alloc,
                               std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >(
         std::move(from)) {
    GUM_CONS_MOV(Bijection);
  }

~Bijection()

template<typename T1 , typename T2 , typename Alloc >

INLINE gum::Bijection< T1, T2, Alloc >::~Bijection

(

)

Class destructor.

Definition at line 1161 of file bijection_tpl.h.

                                                {
    GUM_DESTRUCTOR(Bijection);
  }

Bijection() [6/6]

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 1139 of file bijection_tpl.h.

                                                                                            :
      BijectionImplementation< T1,
                               T2,
                               Alloc,
                               std::is_scalar< T1 >::value && std::is_scalar< T2 >::value >(
         toCopy) {
    GUM_CONS_CPY(Bijection);
  }

Member Function Documentation

_copy_() [1/2]

INLINE void gum::BijectionImplementation< T1, T2, Alloc, Gen >::_copy_ ( const HashTable< T1, T2 *, OtherAlloc > &  f2s )

inherited

Definition at line 57 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_
  }

_copy_() [2/2]

INLINE void gum::BijectionImplementation< T1, T2, Alloc, Gen >::_copy_ ( const HashTable< T1, T2, OtherAlloc > &  f2s )

inherited

Definition at line 532 of file bijection_tpl.h.

                                                 {
    // parse f2s and perform copies
    for (auto iter = f2s.cbegin(); iter != f2s.cend(); ++iter) {
      _firstToSecond_.insert(iter.key(), iter.val());

      try {
        _secondToFirst_.insert(iter.val(), iter.key());
      } catch (...) {
        _firstToSecond_.erase(iter.key());
        throw;
      }
    }

    // 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_
  }

begin()

INLINE BijectionImplementation< T1, T2, Alloc, true >::iterator gum::BijectionImplementation< T1, T2, Alloc >::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.
}

Definition at line 215 of file bijection_tpl.h.

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

beginSafe()

INLINE BijectionImplementation< T1, T2, Alloc, true >::iterator_safe gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 245 of file bijection_tpl.h.

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

capacity()

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

noexceptinherited

Returns the number of hashtables slots used.

Returns

Returns the number of hashtables slots used.

Definition at line 429 of file bijection_tpl.h.

                                                                                     {
    return _firstToSecond_.capacity();
  }

cbegin()

INLINE BijectionImplementation< T1, T2, Alloc, true >::const_iterator gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 222 of file bijection_tpl.h.

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

cbeginSafe()

INLINE BijectionImplementation< T1, T2, Alloc, true >::const_iterator_safe gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 252 of file bijection_tpl.h.

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

cend()

INLINE const BijectionImplementation< T1, T2, Alloc, true >::const_iterator & gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 237 of file bijection_tpl.h.

                                                                        {
    return *(reinterpret_cast< const BijectionIterator< T1, T2 >* >(
       BijectionIteratorStaticEnd::_BijectionIterEnd_));
  }

cendSafe()

INLINE const BijectionImplementation< T1, T2, Alloc, true >::const_iterator_safe & gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 267 of file bijection_tpl.h.

                                                                            {
    return *(reinterpret_cast< const BijectionIteratorSafe< T1, T2 >* >(
       BijectionIteratorStaticEnd::_BijectionIterEndSafe_));
  }

clear()

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

inherited

Removes all the associations from the gum::Bijection.

Definition at line 154 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
  }

emplace() [1/2]

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

inherited

Definition at line 390 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));
  }

emplace() [2/2]

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

args	the arguments passed to the constructor

Exceptions

DuplicateElement

exception is thrown if the association already exists

empty()

INLINE bool gum::BijectionImplementation< T1, T2, Alloc >::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.

Definition at line 397 of file bijection_tpl.h.

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

end()

INLINE const BijectionImplementation< T1, T2, Alloc, true >::iterator & gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 229 of file bijection_tpl.h.

                                                                       {
    return *(reinterpret_cast< const BijectionIterator< T1, T2 >* >(
       BijectionIteratorStaticEnd::_BijectionIterEnd_));
  }

end4Statics()

const BijectionIterator< T1, T2 > & gum::BijectionImplementation< T1, T2, Alloc >::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().

Definition at line 49 of file bijection_tpl.h.

                                                                                                {
    return *(reinterpret_cast< const BijectionIterator< T1, T2 >* >(
       BijectionIteratorStaticEnd::end4Statics()));
  }

endSafe()

INLINE const BijectionImplementation< T1, T2, Alloc, true >::iterator_safe & gum::BijectionImplementation< T1, T2, Alloc >::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
}

Definition at line 259 of file bijection_tpl.h.

                                                                           {
    return *(reinterpret_cast< const BijectionIteratorSafe< T1, T2 >* >(
       BijectionIteratorStaticEnd::_BijectionIterEndSafe_));
  }

endSafe4Statics()

const BijectionIteratorSafe< T1, T2 > & gum::BijectionImplementation< T1, T2, Alloc >::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().

Definition at line 42 of file bijection_tpl.h.

                                                                    {
    return *(reinterpret_cast< const BijectionIteratorSafe< T1, T2 >* >(
       BijectionIteratorStaticEnd::endSafe4Statics()));
  }

eraseFirst()

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::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

first

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

Definition at line 411 of file bijection_tpl.h.

                                                                                       {
    try {
      _secondToFirst_.erase(*_firstToSecond_[first]);
      _firstToSecond_.erase(first);
    } catch (NotFound&) {}
  }

eraseSecond()

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::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

second

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

Definition at line 420 of file bijection_tpl.h.

                                                                                         {
    try {
      _firstToSecond_.erase(*_secondToFirst_[second]);
      _secondToFirst_.erase(second);
    } catch (NotFound&) {}
  }

existsFirst()

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

inherited

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 286 of file bijection_tpl.h.

                                                                                              {
    return _firstToSecond_.exists(first);
  }

existsSecond()

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

inherited

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 292 of file bijection_tpl.h.

                                                                                                {
    return _secondToFirst_.exists(second);
  }

first()

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

inherited

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 274 of file bijection_tpl.h.

                                                                                              {
    return *(_secondToFirst_[second]);
  }

firstWithDefault()

INLINE const T1 & gum::BijectionImplementation< T1, T2, Alloc >::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

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 356 of file bijection_tpl.h.

                                                                                          {
    try {
      return first(second);
    } catch (NotFound&) { return _insert_(val, second)->first; }
  }

insert() [1/2]

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

inherited

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 376 of file bijection_tpl.h.

                                                                                      {
    _insert_(first, second);
  }

insert() [2/2]

INLINE 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

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 383 of file bijection_tpl.h.

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

operator=() [1/4]

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 1177 of file bijection_tpl.h.

                                                                                        {
    Implementation::operator=(toCopy);
    return *this;
  }

operator=() [2/4]

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

toCopy

The gum::Bijection to copy.

Returns

Returns this gum::Bijection.

Definition at line 1168 of file bijection_tpl.h.

                                                                                   {
    Implementation::operator=(toCopy);
    return *this;
  }

operator=() [3/4]

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

toCopy

The gum::Bijection to copy.

Template Parameters

OtherAlloc

The gum::Bijection to copy allocator's type.

operator=() [4/4]

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

bij	The gum::Bijection to move from.

Definition at line 1185 of file bijection_tpl.h.

                                                                           {
    Implementation::operator=(std::move(bij));
    return *this;
  }

resize()

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

inherited

Manually resize the gum::Bijection.

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

Parameters

new_size

The gum::Bijection new size.

Definition at line 435 of file bijection_tpl.h.

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

resizePolicy()

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

noexceptinherited

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();
  }

second()

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

inherited

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 280 of file bijection_tpl.h.

                                                                                              {
    return *(_firstToSecond_[first]);
  }

secondWithDefault()

INLINE const T2 & gum::BijectionImplementation< T1, T2, Alloc >::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

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 367 of file bijection_tpl.h.

                                                                                           {
    try {
      return second(first);
    } catch (NotFound&) { return *(_insert_(first, val)->second); }
  }

setResizePolicy()

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

noexceptinherited

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 442 of file bijection_tpl.h.

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

size()

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

noexceptinherited

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

Returns

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

Definition at line 404 of file bijection_tpl.h.

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

toString()

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

inherited

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();
  }

---

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

• agrum/tools/core/bijection.h
• agrum/tools/core/bijection_tpl.h