gum::BijectionImplementation< T1, T2, Alloc, Gen > Class Template Reference

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

#include <agrum/core/bijection.h>

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

Public Member Functions
template<typename OtherAlloc >
INLINE void	__copy (const HashTable< T1, T2 *, OtherAlloc > &f2s)
template<typename OtherAlloc >
INLINE	BijectionImplementation (const BijectionImplementation< T1, T2, OtherAlloc, Gen > &toCopy)
template<typename OtherAlloc >
INLINE BijectionImplementation< T1, T2, Alloc, Gen > &	operator= (const BijectionImplementation< T1, T2, OtherAlloc, Gen > &toCopy)
template<typename... Args>
INLINE void	emplace (Args &&... args)
template<typename OtherAlloc >
INLINE void	__copy (const HashTable< T1, T2, OtherAlloc > &f2s)
template<typename T1, typename T2, typename Alloc>
INLINE	BijectionImplementation (const BijectionImplementation< T1, T2, Alloc, true > &toCopy)
template<typename OtherAlloc >
INLINE	BijectionImplementation (const BijectionImplementation< T1, T2, OtherAlloc, true > &toCopy)
template<typename T1, typename T2, typename Alloc>
INLINE	BijectionImplementation (BijectionImplementation< T1, T2, Alloc, true > &&toCopy) noexcept
template<typename OtherAlloc >
INLINE BijectionImplementation< T1, T2, Alloc, true > &	operator= (const BijectionImplementation< T1, T2, OtherAlloc, true > &toCopy)
Constructors/destructors
	~BijectionImplementation ()
	Destructor. 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...
template<typename... Args>
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	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	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...

Friends
class	BijectionIteratorSafe< T1, T2 >
	a friend to speed-up accesses More...
class	BijectionIterator< T1, T2 >
	a friend to speed-up accesses More...
class	Bijection< T1, T2, Alloc >
	a friend to speed-up accesses More...
template<typename TT1 , typename TT2 , typename A , bool >
class	BijectionImplementation
	a friend to speed-up accesses 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, bool Gen>
class gum::BijectionImplementation< T1, T2, Alloc, 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.
Alloc	The allocator used for allocating memory.
Gen	If true, this will be replaced by a implementation omptimized for non-scalar types.

Definition at line 83 of file bijection.h.

Member Typedef Documentation

allocator12_type

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 105 of file bijection.h.

allocator21_type

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 107 of file bijection.h.

allocator_type

template<typename T1, typename T2, typename Alloc, bool Gen>

using gum::BijectionImplementation< T1, T2, Alloc, Gen >::allocator_type = Alloc

types for STL compliance

Definition at line 99 of file bijection.h.

const_iterator

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 101 of file bijection.h.

const_iterator_safe

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 103 of file bijection.h.

difference_type

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 98 of file bijection.h.

HashTable12

template<typename T1, typename T2, typename Alloc, bool Gen>

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

private

Alias for more readable code.

Definition at line 639 of file bijection.h.

HashTable21

template<typename T1, typename T2, typename Alloc, bool Gen>

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

private

Alias for more readable code.

Definition at line 640 of file bijection.h.

iterator

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 100 of file bijection.h.

iterator_safe

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 102 of file bijection.h.

size_type

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 97 of file bijection.h.

type1_const_pointer

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 91 of file bijection.h.

type1_const_reference

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 89 of file bijection.h.

type1_pointer

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 90 of file bijection.h.

type1_reference

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 88 of file bijection.h.

type1_type

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 87 of file bijection.h.

type2_const_pointer

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 96 of file bijection.h.

type2_const_reference

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 94 of file bijection.h.

type2_pointer

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 95 of file bijection.h.

type2_reference

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 93 of file bijection.h.

type2_type

template<typename T1, typename T2, typename Alloc, bool Gen>

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

types for STL compliance

Definition at line 92 of file bijection.h.

Constructor & Destructor Documentation

BijectionImplementation() [1/9]

template<typename T1 , typename T2 , typename Alloc >

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

    // make sure the end() iterator is constructed properly
    end4Statics();
    endSafe4Statics();
  }

BijectionImplementation() [2/9]

template<typename T1, typename T2, typename Alloc >

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

    // make sure the end() iterator is constructed properly
    end4Statics();
    endSafe4Statics();
  }

BijectionImplementation() [3/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

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

private

Copy constructor.

Parameters

toCopy

Bijection to copy.

Definition at line 116 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() [4/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

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

private

Generalized copy constructor.

Parameters

toCopy

Bijection to copy.

BijectionImplementation() [5/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

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

privatenoexcept

Move constructor.

Parameters

from	Bijection to move.

Definition at line 137 of file bijection_tpl.h.

                                                                    :
      __firstToSecond(std::move(from.__firstToSecond)),
      __secondToFirst(std::move(from.__secondToFirst)) {
    GUM_CONS_MOV(BijectionImplementation);
  }

~BijectionImplementation()

template<typename T1 , typename T2 , typename Alloc >

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

(

)

Destructor.

Definition at line 147 of file bijection_tpl.h.

                                                                             {
    GUM_DESTRUCTOR(BijectionImplementation);
  }

BijectionImplementation() [6/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE gum::BijectionImplementation< T1, T2, Alloc, Gen >::BijectionImplementation

(

const BijectionImplementation< T1, T2, OtherAlloc, Gen > &

toCopy

)

Definition at line 127 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() [7/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename T1, typename T2, typename Alloc>

INLINE gum::BijectionImplementation< T1, T2, Alloc, Gen >::BijectionImplementation

(

const BijectionImplementation< T1, T2, Alloc, true > &

toCopy

)

Definition at line 575 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() [8/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE gum::BijectionImplementation< T1, T2, Alloc, Gen >::BijectionImplementation

(

const BijectionImplementation< T1, T2, OtherAlloc, true > &

toCopy

)

Definition at line 586 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() [9/9]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename T1, typename T2, typename Alloc>

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

noexcept

Definition at line 596 of file bijection_tpl.h.

                                                                       :
      __firstToSecond(std::move(toCopy.__firstToSecond)),
      __secondToFirst(std::move(toCopy.__secondToFirst)) {
    GUM_CONS_MOV(BijectionImplementation);
  }

Member Function Documentation

__copy() [1/3]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE void gum::BijectionImplementation< T1, T2, Alloc, Gen >::__copy

(

const HashTable< T1, T2 *, OtherAlloc > &

f2s

)

Definition at line 55 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/3]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE void gum::BijectionImplementation< T1, T2, Alloc, Gen >::__copy

(

const HashTable< T1, T2, OtherAlloc > &

f2s

)

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

__copy() [3/3]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

void gum::BijectionImplementation< T1, T2, Alloc, Gen >::__copy ( const HashTable< T1, T2 *, OtherAlloc > &  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.

Template Parameters

OtherAlloc

The allocator used by source.

__insert() [1/2]

template<typename T1, typename T2, typename Alloc , bool Gen>

INLINE BijectionImplementation< T1, T2, Alloc, Gen >::HashTable12::value_type * gum::BijectionImplementation< T1, T2, Alloc, 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 307 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;
  }

__insert() [2/2]

template<typename T1, typename T2, typename Alloc , bool Gen>

INLINE BijectionImplementation< T1, T2, Alloc, Gen >::HashTable12::value_type * gum::BijectionImplementation< T1, T2, Alloc, 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 338 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;
  }

begin()

template<typename T1 , typename T2 , typename Alloc >

INLINE BijectionImplementation< T1, T2, Alloc, true >::iterator gum::BijectionImplementation< T1, T2, Alloc >::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 214 of file bijection_tpl.h.

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

beginSafe()

template<typename T1 , typename T2 , typename Alloc >

INLINE BijectionImplementation< T1, T2, Alloc, true >::iterator_safe gum::BijectionImplementation< T1, T2, Alloc >::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 245 of file bijection_tpl.h.

Referenced by gum::ExactTerminalNodePolicy< GUM_SCALAR >::beginValues().

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

Here is the caller graph for this function:

capacity()

template<typename T1 , typename T2 , typename Alloc >

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

noexcept

Returns the number of hashtables slots used.

Returns

Returns the number of hashtables slots used.

Definition at line 448 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::capacity(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=().

              {
    return __firstToSecond.capacity();
  }

Here is the caller graph for this function:

cbegin()

template<typename T1 , typename T2 , typename Alloc >

INLINE BijectionImplementation< T1, T2, Alloc, true >::const_iterator gum::BijectionImplementation< T1, T2, Alloc >::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 221 of file bijection_tpl.h.

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

cbeginSafe()

template<typename T1 , typename T2 , typename Alloc >

INLINE BijectionImplementation< T1, T2, Alloc, true >::const_iterator_safe gum::BijectionImplementation< T1, T2, Alloc >::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 253 of file bijection_tpl.h.

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

cend()

template<typename T1 , typename T2 , typename Alloc >

INLINE const BijectionImplementation< T1, T2, Alloc, true >::const_iterator & gum::BijectionImplementation< T1, T2, Alloc >::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 237 of file bijection_tpl.h.

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

cendSafe()

template<typename T1 , typename T2 , typename Alloc >

INLINE const BijectionImplementation< T1, T2, Alloc, true >::const_iterator_safe & gum::BijectionImplementation< T1, T2, Alloc >::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 270 of file bijection_tpl.h.

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

clear()

template<typename T1 , typename T2 , typename Alloc >

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

(

)

Removes all the associations from the gum::Bijection.

Definition at line 153 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::BijectionImplementation(), gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::clear(), and gum::ExactTerminalNodePolicy< GUM_SCALAR >::clearAllTerminalNodes().

                                                                   {
    __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
  }

Here is the caller graph for this function:

emplace() [1/2]

template<typename T1 , typename T2 , typename Alloc >

template<typename... Args>

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::emplace

(

Args &&...

args

)

Definition at line 405 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]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename... Args>

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

empty()

template<typename T1 , typename T2 , typename Alloc >

INLINE bool gum::BijectionImplementation< T1, T2, Alloc >::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 412 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::empty(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=().

              {
    GUM_ASSERT(__firstToSecond.empty() == __secondToFirst.empty());
    return __firstToSecond.empty();
  }

Here is the caller graph for this function:

end()

template<typename T1 , typename T2 , typename Alloc >

INLINE const BijectionImplementation< T1, T2, Alloc, true >::iterator & gum::BijectionImplementation< T1, T2, Alloc >::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 228 of file bijection_tpl.h.

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

end4Statics()

template<typename T1 , typename T2 , typename Alloc >

const BijectionIterator< T1, T2 > & gum::BijectionImplementation< T1, T2, Alloc >::end4Statics ( )

static

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

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

endSafe()

template<typename T1 , typename T2 , typename Alloc >

INLINE const BijectionImplementation< T1, T2, Alloc, true >::iterator_safe & gum::BijectionImplementation< T1, T2, Alloc >::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 261 of file bijection_tpl.h.

Referenced by gum::ExactTerminalNodePolicy< GUM_SCALAR >::hasValue().

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

Here is the caller graph for this function:

endSafe4Statics()

template<typename T1 , typename T2 , typename Alloc >

const BijectionIteratorSafe< T1, T2 > & gum::BijectionImplementation< T1, T2, Alloc >::endSafe4Statics ( )

static

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

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

eraseFirst()

template<typename T1, typename T2 , typename Alloc , bool Gen>

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::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 429 of file bijection_tpl.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__removeNode(), and gum::ExactTerminalNodePolicy< GUM_SCALAR >::eraseTerminalNode().

                                                                              {
    try {
      __secondToFirst.erase(*__firstToSecond[first]);
      __firstToSecond.erase(first);
    } catch (NotFound&) {}
  }

Here is the caller graph for this function:

eraseSecond()

template<typename T1 , typename T2, typename Alloc , bool Gen>

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::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 439 of file bijection_tpl.h.

                                                                                {
    try {
      __firstToSecond.erase(*__secondToFirst[second]);
      __secondToFirst.erase(second);
    } catch (NotFound&) {}
  }

existsFirst()

template<typename T1, typename T2 , typename Alloc , bool Gen>

INLINE bool gum::BijectionImplementation< T1, T2, Alloc >::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 291 of file bijection_tpl.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__removeNode(), and gum::ExactTerminalNodePolicy< GUM_SCALAR >::existsTerminalNodeWithId().

                            {
    return __firstToSecond.exists(first);
  }

Here is the caller graph for this function:

existsSecond()

template<typename T1 , typename T2, typename Alloc , bool Gen>

INLINE bool gum::BijectionImplementation< T1, T2, Alloc >::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 298 of file bijection_tpl.h.

Referenced by gum::ExactTerminalNodePolicy< GUM_SCALAR >::existsTerminalNodeWithValue().

                             {
    return __secondToFirst.exists(second);
  }

Here is the caller graph for this function:

first()

template<typename T1 , typename T2, typename Alloc , bool Gen>

INLINE const T1 & gum::BijectionImplementation< T1, T2, Alloc >::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 278 of file bijection_tpl.h.

Referenced by gum::prm::gspan::StrictSearch< GUM_SCALAR >::__buildPatternGraph(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), gum::learning::genericBNLearner::Database::idFromName(), gum::ExactTerminalNodePolicy< GUM_SCALAR >::terminalNodeId(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrderNames().

                                                                                          {
    return *(__secondToFirst[second]);
  }

Here is the caller graph for this function:

firstWithDefault()

template<typename T1, typename T2, typename Alloc , bool Gen>

INLINE const T1 & gum::BijectionImplementation< T1, T2, Alloc >::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 368 of file bijection_tpl.h.

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

insert() [1/2]

template<typename T1, typename T2, typename Alloc , bool Gen>

INLINE void gum::BijectionImplementation< T1, T2, Alloc, 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 389 of file bijection_tpl.h.

Referenced by gum::prm::gspan::StrictSearch< GUM_SCALAR >::__buildPatternGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::__copy(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::ExactTerminalNodePolicy< GUM_SCALAR >::addTerminalNode(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator(), and gum::learning::genericBNLearner::Database::Database().

                                                                             {
    __insert(first, second);
  }

Here is the caller graph for this function:

insert() [2/2]

template<typename T1, typename T2, typename Alloc , bool Gen>

INLINE void gum::BijectionImplementation< T1, T2, Alloc, 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 396 of file bijection_tpl.h.

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

operator=() [1/5]

template<typename T1, typename T2, typename Alloc, bool Gen>

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

private

Copy operator.

Parameters

toCopy

Bijection to copy.

Returns

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

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

operator=() [2/5]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

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

private

Generalized copy operator.

Parameters

toCopy

Bijection to copy.

Returns

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

operator=() [3/5]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE BijectionImplementation< T1, T2, Alloc, Gen >& gum::BijectionImplementation< T1, T2, Alloc, Gen >::operator=

(

const BijectionImplementation< T1, T2, OtherAlloc, Gen > &

toCopy

)

Definition at line 182 of file bijection_tpl.h.

                                                                          {
    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;
  }

operator=() [4/5]

template<typename T1, typename T2, typename Alloc, bool Gen>

INLINE BijectionImplementation< T1, T2, Alloc, Gen > & gum::BijectionImplementation< T1, T2, Alloc, Gen >::operator= ( BijectionImplementation< T1, T2, Alloc, 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 197 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;
  }

operator=() [5/5]

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE BijectionImplementation< T1, T2, Alloc, true >& gum::BijectionImplementation< T1, T2, Alloc, Gen >::operator=

(

const BijectionImplementation< T1, T2, OtherAlloc, true > &

toCopy

)

Definition at line 705 of file bijection_tpl.h.

                                                                           {
    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;
  }

resize()

template<typename T1 , typename T2 , typename Alloc >

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::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 456 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::resize().

                                                                        {
    __firstToSecond.resize(new_size);
    __secondToFirst.resize(new_size);
  }

Here is the caller graph for this function:

resizePolicy()

template<typename T1 , typename T2 , typename Alloc >

INLINE bool gum::BijectionImplementation< T1, T2, Alloc >::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 471 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::resizePolicy().

              {
    return __firstToSecond.resizePolicy();
  }

Here is the caller graph for this function:

second()

template<typename T1, typename T2 , typename Alloc , bool Gen>

INLINE const T2 & gum::BijectionImplementation< T1, T2, Alloc >::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 285 of file bijection_tpl.h.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClassDag(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrderFromCSV(), gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray(), gum::learning::genericBNLearner::Database::nameFromId(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), and gum::ExactTerminalNodePolicy< GUM_SCALAR >::terminalNodeValue().

                                                                                          {
    return *(__firstToSecond[first]);
  }

Here is the caller graph for this function:

secondWithDefault()

template<typename T1, typename T2, typename Alloc , bool Gen>

INLINE const T2 & gum::BijectionImplementation< T1, T2, Alloc >::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 379 of file bijection_tpl.h.

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

setResizePolicy()

template<typename T1 , typename T2 , typename Alloc >

INLINE void gum::BijectionImplementation< T1, T2, Alloc >::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 463 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::setResizePolicy().

                                     {
    __firstToSecond.setResizePolicy(new_policy);
    __secondToFirst.setResizePolicy(new_policy);
  }

Here is the caller graph for this function:

size()

template<typename T1 , typename T2 , typename Alloc >

INLINE Size gum::BijectionImplementation< T1, T2, Alloc >::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 420 of file bijection_tpl.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::size().

              {
    GUM_ASSERT(__firstToSecond.size() == __secondToFirst.size());
    return __firstToSecond.size();
  }

Here is the caller graph for this function:

toString()

template<typename T1 , typename T2 , typename Alloc >

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

(

)

const

Returns a friendly representatin of the gum::Bijection.

Returns

Returns a friendly representatin of the gum::Bijection.

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

Friends And Related Function Documentation

BijectionImplementation

template<typename T1, typename T2, typename Alloc, bool Gen>

template<typename TT1 , typename TT2 , typename A , bool >

friend class BijectionImplementation

friend

a friend to speed-up accesses

Definition at line 649 of file bijection.h.

Bijection< T1, T2, Alloc >

template<typename T1, typename T2, typename Alloc, bool Gen>

friend class Bijection< T1, T2, Alloc >

friend

a friend to speed-up accesses

Definition at line 647 of file bijection.h.

BijectionIterator< T1, T2 >

template<typename T1, typename T2, typename Alloc, bool Gen>

friend class BijectionIterator< T1, T2 >

friend

a friend to speed-up accesses

Definition at line 646 of file bijection.h.

BijectionIteratorSafe< T1, T2 >

template<typename T1, typename T2, typename Alloc, bool Gen>

friend class BijectionIteratorSafe< T1, T2 >

friend

a friend to speed-up accesses

Definition at line 645 of file bijection.h.

Member Data Documentation

__firstToSecond

template<typename T1, typename T2, typename Alloc, bool Gen>

HashTable12 gum::BijectionImplementation< T1, T2, Alloc, Gen >::__firstToSecond

private

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

Definition at line 658 of file bijection.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::BijectionImplementation(), gum::BijectionIterator< int, int >::BijectionIterator(), gum::BijectionIteratorSafe< NodeId, GUM_SCALAR >::BijectionIteratorSafe(), and gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=().

__secondToFirst

template<typename T1, typename T2, typename Alloc, bool Gen>

HashTable21 gum::BijectionImplementation< T1, T2, Alloc, Gen >::__secondToFirst

private

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

Definition at line 661 of file bijection.h.

Referenced by gum::BijectionImplementation< Idx, const std::string *, std::allocator< const std::string * >, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value >::operator=().

---

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

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