gum::SequenceImplementation< Key, Alloc, Gen > Class Template Reference

The internal class for storing (ordered) sequences of objects. More...

#include <agrum/core/sequence.h>

Collaboration diagram for gum::SequenceImplementation< Key, Alloc, Gen >:

Public Member Functions
template<typename OtherAlloc >
INLINE void	__copy (const SequenceImplementation< Key, OtherAlloc, Gen > &aSeq)
template<typename OtherAlloc >
INLINE	SequenceImplementation (const SequenceImplementation< Key, OtherAlloc, Gen > &aSeq)
template<typename OtherAlloc >
INLINE SequenceImplementation< Key, Alloc, Gen > &	operator= (const SequenceImplementation< Key, OtherAlloc, Gen > &aSeq)
template<typename... Args>
INLINE void	emplace (Args &&... args)
template<typename OtherAlloc >
INLINE bool	operator!= (const SequenceImplementation< Key, OtherAlloc, Gen > &k) const
template<typename OtherAlloc >
INLINE void	__copy (const SequenceImplementation< Key, OtherAlloc, true > &aSeq)
template<typename Key, typename Alloc>
	SequenceImplementation (const SequenceImplementation< Key, Alloc, true > &aSeq)
template<typename OtherAlloc >
	SequenceImplementation (const SequenceImplementation< Key, OtherAlloc, true > &aSeq)
template<typename Key, typename Alloc>
INLINE	SequenceImplementation (SequenceImplementation< Key, Alloc, true > &&aSeq)
template<typename OtherAlloc >
INLINE SequenceImplementation< Key, Alloc, true > &	operator= (const SequenceImplementation< Key, OtherAlloc, true > &aSeq)
template<typename OtherAlloc >
bool	operator== (const SequenceImplementation< Key, OtherAlloc, true > &k) const
template<typename OtherAlloc >
INLINE bool	operator!= (const SequenceImplementation< Key, OtherAlloc, true > &k) const
Destructor
	~SequenceImplementation () noexcept
	Class destructor. More...
Iterators
iterator_safe	beginSafe () const
	Returns a safe begin iterator. More...
iterator_safe	rbeginSafe () const
	Returns a safe rbegin iterator. More...
const iterator_safe &	endSafe () const noexcept
	Returns the safe end iterator. More...
const iterator_safe &	rendSafe () const noexcept
	Returns the safe rend iterator. More...
iterator	begin () const
	Returns an unsafe begin iterator. More...
iterator	rbegin () const
	Returns an unsafe rbegin iterator. More...
const iterator &	end () const noexcept
	Returns the unsafe end iterator. More...
const iterator &	rend () const noexcept
	Returns the unsafe rend iterator. More...
Operators
SequenceImplementation< Key, Alloc, Gen > &	operator<< (const Key &k)
	Insert k at the end of the sequence (synonym for insert). More...
SequenceImplementation< Key, Alloc, Gen > &	operator<< (Key &&k)
	Insert k at the end of the sequence (synonym for insert). More...
SequenceImplementation< Key, Alloc, Gen > &	operator>> (const Key &k)
	Remove k in the sequence (synonym for erase). More...
const Key &	operator[] (Idx i) const
	Returns the element at position i (synonym for atPos). More...
template<typename OtherAlloc >
bool	operator== (const SequenceImplementation< Key, OtherAlloc, Gen > &k) const
	Returns true if the content of k equals that of *this. More...
template<typename OtherAlloc >
bool	operator!= (const SequenceImplementation< Key, OtherAlloc, Gen > &k) const
	Returns true if the content of k is different from that of *this. More...
Accessors / Modifiers
void	clear ()
	Clear the sequence. More...
Size	size () const noexcept
	Returns the size of the sequence. More...
bool	empty () const noexcept
	Return true if empty. More...
bool	exists (const Key &k) const
	Check the existence of k in the sequence. More...
void	insert (const Key &k)
	Insert an element at the end of the sequence. More...
void	insert (Key &&k)
	Move an element at the end of the sequence. More...
template<typename... Args>
void	emplace (Args &&... args)
	Emplace a new element in the sequence. More...
void	erase (const Key &k)
	Remove an element from the sequence. More...
void	erase (const iterator_safe &k)
	Remove from the sequence the element pointed to by the iterator. More...
const Key &	atPos (Idx i) const
	Returns the object at the pos i. More...
Idx	pos (const Key &key) const
	Returns the position of the object passed in argument (if it exists). More...
void	setAtPos (Idx i, const Key &newKey)
	Change the value. More...
void	setAtPos (Idx i, Key &&newKey)
	Change the value. More...
void	swap (Idx i, Idx j)
	Swap index. More...
const Key &	front () const
	Returns the first element of the element. More...
const Key &	back () const
	Returns the last element of the sequence. More...
std::string	toString () const
	Displays the content of the sequence. More...
void	resize (Size new_size)
	Modifies the size of the internal structures of the sequence. More...

Public Types
using	value_type = Key
	Types for STL compliance. More...
using	reference = Key &
	Types for STL compliance. More...
using	const_reference = const Key &
	Types for STL compliance. More...
using	pointer = Key *
	Types for STL compliance. More...
using	const_pointer = const Key *
	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 = SequenceIterator< Key >
	Types for STL compliance. More...
using	const_iterator = SequenceIterator< Key >
	Types for STL compliance. More...
using	iterator_safe = SequenceIteratorSafe< Key >
	Types for STL compliance. More...
using	const_iterator_safe = SequenceIteratorSafe< Key >
	Types for STL compliance. More...

Friends
template<typename K , typename A , bool >
class	SequenceImplementation
	Friends to speed up access. More...
class	SequenceIteratorSafe< Key >
	Friends to speed up access. More...
class	Sequence< Key, Alloc >
	Friends to speed up access. More...

Detailed Description

template<typename Key, typename Alloc, bool Gen>
class gum::SequenceImplementation< Key, Alloc, Gen >

The internal class for storing (ordered) sequences of objects.

A SequenceImplementation<Key,Alloc,bool Gen> is a specialized version of of a Sequence<Key,Alloc>. It shall not be used by itself but rather through the Sequence class. A SequenceImplementation is quite similar to a vector<Key> in that it stores an ordered set of elements. The main difference between these two data structures lies in the fact that, given a key, it is possible to retrieve from a SequenceImplementation the index in the vector where the key lies in O(1). As a result, it is not possible to insert a given element twice in the sequence, that is, all the Keys must be different.

When the Boolean template parameter gen is false, SequenceImplementation implements a very generic sequence. This allows having Sequences containing elements of virtually any class or type. When the Boolean gen is equal to true, the SequenceImplementation shall contain only scalar types (integers, floats, pointers, etc). As such, knowning that the element is a scalar enables to optimize the code of the sequences. Determining whether gen should be set to true or false is not left to the developper but is determined by the compiler itself at compile time.

Template Parameters

Key	The elements type stored in the sequence.
Alloc	The values allocator.
Gen	Used for meta-programation.

Definition at line 90 of file sequence.h.

Member Typedef Documentation

allocator_type

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::allocator_type = Alloc

Types for STL compliance.

Definition at line 109 of file sequence.h.

const_iterator

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::const_iterator = SequenceIterator< Key >

Types for STL compliance.

Definition at line 111 of file sequence.h.

const_iterator_safe

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::const_iterator_safe = SequenceIteratorSafe< Key >

Types for STL compliance.

Definition at line 113 of file sequence.h.

const_pointer

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::const_pointer = const Key*

Types for STL compliance.

Definition at line 106 of file sequence.h.

const_reference

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::const_reference = const Key&

Types for STL compliance.

Definition at line 104 of file sequence.h.

difference_type

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::difference_type = std::ptrdiff_t

Types for STL compliance.

Definition at line 108 of file sequence.h.

iterator

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::iterator = SequenceIterator< Key >

Types for STL compliance.

Definition at line 110 of file sequence.h.

iterator_safe

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::iterator_safe = SequenceIteratorSafe< Key >

Types for STL compliance.

Definition at line 112 of file sequence.h.

pointer

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::pointer = Key*

Types for STL compliance.

Definition at line 105 of file sequence.h.

reference

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::reference = Key&

Types for STL compliance.

Definition at line 103 of file sequence.h.

size_type

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::size_type = std::size_t

Types for STL compliance.

Definition at line 107 of file sequence.h.

value_type

template<typename Key, typename Alloc, bool Gen>

using gum::SequenceImplementation< Key, Alloc, Gen >::value_type = Key

Types for STL compliance.

Definition at line 102 of file sequence.h.

Constructor & Destructor Documentation

SequenceImplementation() [1/9]

template<typename Key , typename Alloc >

INLINE gum::SequenceImplementation< Key, Alloc >::SequenceImplementation ( Size  size_param = HashTableConst::default_size )

private

Default constructor.

Parameters

size_param

The intial size of the gum::SequenceImplementation.

Definition at line 294 of file sequence_tpl.h.

                      :
      __h(size_param),
      __end_safe{*this}, __rend_safe{*this} {
    // for debugging purposes
    GUM_CONSTRUCTOR(SequenceImplementation);
    __rend_safe.__setAtRend();
    __update_end();
  }

SequenceImplementation() [2/9]

template<typename Key, typename Alloc >

INLINE gum::SequenceImplementation< Key, Alloc >::SequenceImplementation ( std::initializer_list< Key >  list )

private

Initializer list constructor.

Parameters

list	The initializer list.

Definition at line 306 of file sequence_tpl.h.

                                      :
      __end_safe{*this},
      __rend_safe{*this} {
    GUM_CONSTRUCTOR(SequenceImplementation);
    __rend_safe.__setAtRend();
    for (const auto& elt : list) {
      insert(elt);   // performs the __update_end ()
    }
  }

SequenceImplementation() [3/9]

template<typename Key, typename Alloc, bool Gen>

INLINE gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation ( const SequenceImplementation< Key, Alloc, Gen > &  aSeq )

private

Copy constructor.

Parameters

aSeq	The sequence the elements of which will be copied.

Warning

The elements of the newly constructed sequence are copies of those in aSeq.

Definition at line 319 of file sequence_tpl.h.

                                                            :
      __end_safe{*this},
      __rend_safe{*this} {
    // for debugging purposes
    GUM_CONS_CPY(SequenceImplementation);
    __rend_safe.__setAtRend();
    __copy(aSeq);   // performs the __update_end ()
  }

SequenceImplementation() [4/9]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation ( const SequenceImplementation< Key, OtherAlloc, Gen > &  aSeq )

private

Generalised copy constructor.

Template Parameters

OtherAlloc

The other gum::SequenceImplementation allocator.

Parameters

aSeq	The sequence the elements of which will be copied.

Warning

The elements of the newly constructed sequence are copies of those in aSeq.

SequenceImplementation() [5/9]

template<typename Key, typename Alloc, bool Gen>

INLINE gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation ( SequenceImplementation< Key, Alloc, Gen > &&  aSeq )

private

Move constructor.

Parameters

aSeq	The gum::SequenceImplementation to move/

Definition at line 344 of file sequence_tpl.h.

                                                       :
      __h(std::move(aSeq.__h)),
      __v(std::move(aSeq.__v)), __end_safe{*this}, __rend_safe{*this} {
    // for debugging purposes
    GUM_CONS_MOV(SequenceImplementation);
    __rend_safe.__setAtRend();
    __update_end();
  }

~SequenceImplementation()

template<typename Key , typename Alloc >

gum::SequenceImplementation< Key, Alloc >::~SequenceImplementation ( )

noexcept

Class destructor.

Definition at line 357 of file sequence_tpl.h.

                                        {
    GUM_DESTRUCTOR(SequenceImplementation);
  }

SequenceImplementation() [6/9]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation

(

const SequenceImplementation< Key, OtherAlloc, Gen > &

aSeq

)

Definition at line 332 of file sequence_tpl.h.

                                                                 :
      __end_safe{*this},
      __rend_safe{*this} {
    // for debugging purposes
    GUM_CONS_CPY(SequenceImplementation);
    __rend_safe.__setAtRend();
    __copy(aSeq);   // performs the __update_end ()
  }

SequenceImplementation() [7/9]

template<typename Key, typename Alloc, bool Gen>

template<typename Key, typename Alloc>

gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation

(

const SequenceImplementation< Key, Alloc, true > &

aSeq

)

Definition at line 753 of file sequence_tpl.h.

                                                             :
      __h(aSeq.__h),
      __v(aSeq.__v), __end_safe{*this}, __rend_safe{*this} {
    // for debugging purposes
    GUM_CONS_CPY(SequenceImplementation);
    __rend_safe.__setAtRend();
    __end_safe.__setAtEnd();
  }

SequenceImplementation() [8/9]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation

(

const SequenceImplementation< Key, OtherAlloc, true > &

aSeq

)

Definition at line 766 of file sequence_tpl.h.

                                                                  :
      __h(aSeq.size() / 2),
      __end_safe{*this}, __rend_safe{*this} {
    // for debugging purposes
    GUM_CONS_CPY(SequenceImplementation);
    __rend_safe.__setAtRend();
    __copy(aSeq);
  }

SequenceImplementation() [9/9]

template<typename Key, typename Alloc, bool Gen>

template<typename Key, typename Alloc>

INLINE gum::SequenceImplementation< Key, Alloc, Gen >::SequenceImplementation

(

SequenceImplementation< Key, Alloc, true > &&

aSeq

)

Definition at line 778 of file sequence_tpl.h.

                                                        :
      __h(std::move(aSeq.__h)),
      __v(std::move(aSeq.__v)), __end_safe{*this}, __rend_safe{*this} {
    // for debugging purposes
    GUM_CONS_MOV(SequenceImplementation);
    __rend_safe.__setAtRend();
    __end_safe.__setAtEnd();
  }

Member Function Documentation

__copy() [1/3]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::__copy

(

const SequenceImplementation< Key, OtherAlloc, Gen > &

aSeq

)

Definition at line 280 of file sequence_tpl.h.

                                                                 {
    clear();

    for (Size i = 0; i < aSeq.size(); ++i) {
      Key& new_key = const_cast< Key& >(__h.insert(*(aSeq.__v[i]), i).first);
      __v.push_back(&new_key);
    }

    __update_end();
  }

__copy() [2/3]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

void gum::SequenceImplementation< Key, Alloc, Gen >::__copy ( const SequenceImplementation< Key, OtherAlloc, Gen > &  aSeq )

private

Clears the current sequence and fill it with copies the element of aSeq.

Template Parameters

OtherAlloc

The other gum::SequenceImplementation allocator.

Parameters

aSeq	The gum::SequenceImplementation to copy.

__copy() [3/3]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::__copy

(

const SequenceImplementation< Key, OtherAlloc, true > &

aSeq

)

Definition at line 714 of file sequence_tpl.h.

                                                                  {
    clear();

    for (Size i = 0; i < aSeq.size(); ++i) {
      __h.insert(aSeq.__v[i], i);
      __v.push_back(aSeq.__v[i]);
    }

    __update_end();
  }

__insert()

template<typename Key, typename Alloc, bool Gen>

void gum::SequenceImplementation< Key, Alloc, Gen >::__insert ( HashTableBucket< Key, Idx > &&  bucket )

private

Insert an element at the end of the sequence.

Parameters

bucket

The bucket holing the store to insert.

__update_end()

template<typename Key , typename Alloc >

INLINE void gum::SequenceImplementation< Key, Alloc >::__update_end ( )

privatenoexcept

A method to update the end iterator after changes in the sequence.

Definition at line 265 of file sequence_tpl.h.

                                                                               {
    __end_safe.__setAtEnd();
  }

atPos()

template<typename Key , typename Alloc >

INLINE const Key & gum::SequenceImplementation< Key, Alloc >::atPos

(

Idx

i

)

const

Returns the object at the pos i.

Parameters

i	The position of the element to return.

Returns

Returns the object at the pos i.

Exceptions

NotFound

Raised if the element does not exist.

Definition at line 500 of file sequence_tpl.h.

Referenced by gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::operator[]().

                                                                                {
    if (i >= __h.size()) {
      GUM_ERROR(OutOfBounds,
                "index " << i << " for a sequence of size" << __h.size());
    }

    return *(__v[i]);
  }

Here is the caller graph for this function:

back()

template<typename Key , typename Alloc >

INLINE const Key & gum::SequenceImplementation< Key, Alloc >::back

(

)

const

Returns the last element of the sequence.

Returns

Returns the last element of the sequence.

Exceptions

NotFound

Raised if the sequence is empty.

Definition at line 568 of file sequence_tpl.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__removeBarrenNodes(), and gum::DiGraph::__topologicalOrder().

                                                                          {
    return atPos(size() - 1);
  }

Here is the caller graph for this function:

begin()

template<typename Key , typename Alloc >

INLINE SequenceIterator< Key > gum::SequenceImplementation< Key, Alloc >::begin

(

)

const

Returns an unsafe begin iterator.

Returns

Returns an unsafe begin iterator.

Definition at line 657 of file sequence_tpl.h.

Referenced by gum::InfluenceDiagramGenerator< GUM_SCALAR >::__checkTemporalOrder(), and gum::InfluenceDiagram< GUM_SCALAR >::decisionOrderExists().

                                                                {
    return SequenceIterator< Key >{*this};
  }

Here is the caller graph for this function:

beginSafe()

template<typename Key , typename Alloc >

INLINE SequenceIteratorSafe< Key > gum::SequenceImplementation< Key, Alloc >::beginSafe

(

)

const

Returns a safe begin iterator.

Returns

Returns a safe begin iterator.

Definition at line 627 of file sequence_tpl.h.

Referenced by gum::FMDP< double >::beginActions(), gum::TaxiSimulator::beginActions(), gum::FactorySimulator::beginActions(), and gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::beginSafe().

                                                                    {
    return SequenceIteratorSafe< Key >{*this};
  }

Here is the caller graph for this function:

clear()

template<typename Key , typename Alloc >

INLINE void gum::SequenceImplementation< Key, Alloc >::clear

(

)

Clear the sequence.

Definition at line 271 of file sequence_tpl.h.

Referenced by gum::GibbsOperator< GUM_SCALAR >::__updateSamplingNodes(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::resize(), and gum::DiGraph::topologicalOrder().

                                                               {
    __h.clear();
    __v.clear();
    __update_end();
  }

Here is the caller graph for this function:

emplace() [1/2]

template<typename Key, typename Alloc, bool Gen>

template<typename... Args>

void gum::SequenceImplementation< Key, Alloc, Gen >::emplace

(

Args &&...

args

)

Emplace a new element in the sequence.

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

Template Parameters

Args	The arguments types passed to the constructor.

Parameters

args	The arguments passed to the constructor.

Exceptions

DuplicateElement

Raised if the sequence contains already k.

emplace() [2/2]

template<typename Key , typename Alloc >

template<typename... Args>

INLINE void gum::SequenceImplementation< Key, Alloc >::emplace

(

Args &&...

args

)

Definition at line 427 of file sequence_tpl.h.

                                                                               {
    Key  key(std::forward< Args >(args)...);
    Key& new_key =
       const_cast< Key& >(__h.insert(std::move(key), __h.size()).first);
    __v.push_back(&new_key);
    __update_end();
  }

empty()

template<typename Key , typename Alloc >

INLINE bool gum::SequenceImplementation< Key, Alloc >::empty ( ) const

noexcept

Return true if empty.

Returns

Return true if empty.

Definition at line 44 of file sequence_tpl.h.

Referenced by gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::empty().

                                                                              {
    return __h.empty();
  }

Here is the caller graph for this function:

end()

template<typename Key , typename Alloc >

INLINE const SequenceIterator< Key > & gum::SequenceImplementation< Key, Alloc >::end ( ) const

noexcept

Returns the unsafe end iterator.

Returns

Returns the unsafe end iterator.

Definition at line 664 of file sequence_tpl.h.

Referenced by gum::InfluenceDiagramGenerator< GUM_SCALAR >::__checkTemporalOrder(), and gum::InfluenceDiagram< GUM_SCALAR >::decisionOrderExists().

                                                                             {
    return __end_safe;
  }

Here is the caller graph for this function:

endSafe()

template<typename Key , typename Alloc >

INLINE const SequenceIteratorSafe< Key > & gum::SequenceImplementation< Key, Alloc >::endSafe ( ) const

noexcept

Returns the safe end iterator.

Returns

Returns the safe end iterator.

Definition at line 634 of file sequence_tpl.h.

Referenced by gum::FMDP< double >::endActions(), gum::TaxiSimulator::endActions(), gum::FactorySimulator::endActions(), and gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::endSafe().

                                                                                 {
    return __end_safe;
  }

Here is the caller graph for this function:

erase() [1/2]

template<typename Key, typename Alloc , bool Gen>

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::erase

(

const Key &

k

)

Remove an element from the sequence.

If the element cannot be found, the function does nothing. In particular, it throws no exception. Complexity \(o(n)\) (need to change the position of at most the n elements).

Parameters

k	The element to remove.

Definition at line 453 of file sequence_tpl.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__removeBarrenNodes(), gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::clean(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::erase(), and gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator=().

                                                                           {
    // get the position of the element to remove
    Idx pos;

    try {
      pos = __h[k];
    } catch (NotFound&) { return; }

    // erase the element
    __v.erase(__v.begin() + pos);
    for (Idx i = pos, nb_elts = __h.size() - 1; i < nb_elts; ++i) {
      --__h[*(__v[i])];
    }
    __h.erase(k);

    __update_end();
  }

Here is the caller graph for this function:

erase() [2/2]

template<typename Key, typename Alloc >

INLINE void gum::SequenceImplementation< Key, Alloc >::erase

(

const iterator_safe &

k

)

Remove from the sequence the element pointed to by the iterator.

If the element cannot be found, the function does nothing. In particular, it throws no exception. Complexity \(o(n)\) (need to change the position of at most the n elements)

Parameters

k	The iterator poiting to the element to remove.

Definition at line 474 of file sequence_tpl.h.

                                                                               {
    if (iter.pos() >= size()) return;

    // erase the element
    Idx  pos = iter.pos();
    Key* key = __v[pos];
    __v.erase(__v.begin() + pos);

    for (Idx i = pos, nb_elts = __h.size() - 1; i < nb_elts; ++i) {
      --__h[*(__v[i])];
    }
    __h.erase(*key);

    __update_end();
  }

exists()

template<typename Key, typename Alloc , bool Gen>

INLINE bool gum::SequenceImplementation< Key, Alloc >::exists

(

const Key &

k

)

const

Check the existence of k in the sequence.

The complexity is \(o(1)\).

Parameters

k	The key to check for existence.

Returns

Returns true if k is in the gum::SequenceImplementation.

Definition at line 402 of file sequence_tpl.h.

Referenced by gum::DiGraph::__topologicalOrder(), gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::exists(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::exists(), and gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator=().

                                                                         {
    return __h.exists(k);
  }

Here is the caller graph for this function:

front()

template<typename Key , typename Alloc >

INLINE const Key & gum::SequenceImplementation< Key, Alloc >::front

(

)

const

Returns the first element of the element.

Returns

Returns the first element of the element.

Exceptions

NotFound

Raised if the sequence is empty.

Definition at line 562 of file sequence_tpl.h.

                                                                           {
    return atPos(0);
  }

insert() [1/2]

template<typename Key, typename Alloc , bool Gen>

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::insert

(

const Key &

k

)

Insert an element at the end of the sequence.

The complexity is \(o(1)\).

Parameters

k	The element to insert.

Exceptions

DuplicateElement

Raised if the sequence contains already k.

Definition at line 408 of file sequence_tpl.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__initElimOrder(), gum::prm::SVE< GUM_SCALAR >::__initElimOrder(), gum::prm::StructuredInference< GUM_SCALAR >::__removeBarrenNodes(), gum::DiGraph::__topologicalOrder(), gum::GibbsOperator< GUM_SCALAR >::__updateSamplingNodes(), gum::InfluenceDiagram< GUM_SCALAR >::_getChildrenDecision(), gum::ActionSet::ActionSet(), gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::ArgMaxSet(), gum::ActionSet::operator=(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator=(), and gum::TaxiSimulator::TaxiSimulator().

                                                                            {
    // k will be added at the end. Insert the new key into the hashtable
    Key& new_key = const_cast< Key& >(__h.insert(k, __h.size()).first);
    __v.push_back(&new_key);
    __update_end();
  }

Here is the caller graph for this function:

insert() [2/2]

template<typename Key, typename Alloc , bool Gen>

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::insert

(

Key &&

k

)

Move an element at the end of the sequence.

The complexity is \(o(1)\).

Parameters

k	The element to insert.

Exceptions

DuplicateElement

Raised if the sequence contains already k.

Definition at line 417 of file sequence_tpl.h.

                                                                       {
    // k will be added at the end. Insert the new key into the hashtable
    Key& new_key = const_cast< Key& >(__h.insert(std::move(k), __h.size()).first);
    __v.push_back(&new_key);
    __update_end();
  }

operator!=() [1/3]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

bool gum::SequenceImplementation< Key, Alloc, Gen >::operator!=

(

const SequenceImplementation< Key, OtherAlloc, Gen > &

k

)

const

Returns true if the content of k is different from that of *this.

Note that two sequences are equal if and only if they contain the same variables (using Key::operator==) in the same order.

Template Parameters

OtherAlloc

The other gum::SequenceImplementation allocator.

Parameters

k	The other gum::SequenceImplementation. Returns true if both gum::SequenceImplementation are not equal.

operator!=() [2/3]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE bool gum::SequenceImplementation< Key, Alloc, Gen >::operator!=

(

const SequenceImplementation< Key, OtherAlloc, Gen > &

k

)

const

Definition at line 611 of file sequence_tpl.h.

                                                                                        {
    return !operator==(k);
  }

operator!=() [3/3]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE bool gum::SequenceImplementation< Key, Alloc, Gen >::operator!=

(

const SequenceImplementation< Key, OtherAlloc, true > &

k

)

const

Definition at line 1011 of file sequence_tpl.h.

                                                                                         {
    return !operator==(k);
  }

operator<<() [1/2]

template<typename Key, typename Alloc , bool Gen>

INLINE SequenceImplementation< Key, Alloc, Gen > & gum::SequenceImplementation< Key, Alloc, Gen >::operator<<

(

const Key &

k

)

Insert k at the end of the sequence (synonym for insert).

Parameters

k	The key we wish to insert in the sequence.

Returns

Returns this gum::SequenceImplementation.

Exceptions

DuplicateElement

Raised if the sequence contains already k.

Definition at line 438 of file sequence_tpl.h.

                                                                       {
    insert(k);
    return *this;
  }

operator<<() [2/2]

template<typename Key, typename Alloc , bool Gen>

INLINE SequenceImplementation< Key, Alloc, Gen > & gum::SequenceImplementation< Key, Alloc, Gen >::operator<<

(

Key &&

k

)

Insert k at the end of the sequence (synonym for insert).

Parameters

k	The key we wish to insert in the sequence.

Returns

Returns this gum::SequenceImplementation.

Exceptions

DuplicateElement

Raised if the sequence contains already k.

Definition at line 446 of file sequence_tpl.h.

                                                                  {
    insert(std::move(k));
    return *this;
  }

operator=() [1/5]

template<typename Key, typename Alloc, bool Gen>

INLINE SequenceImplementation< Key, Alloc, Gen > & gum::SequenceImplementation< Key, Alloc, Gen >::operator= ( const SequenceImplementation< Key, Alloc, Gen > &  aSeq )

private

Copy operator.

Parameters

aSeq	The sequence to copy.

Returns

Returns a ref to this.

Definition at line 365 of file sequence_tpl.h.

                                                                          {
    // avoid self assignment
    if (&aSeq != this) {
      __copy(aSeq);   // performs the __update_end ()
    }

    return *this;
  }

operator=() [2/5]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

SequenceImplementation< Key, Alloc, Gen >& gum::SequenceImplementation< Key, Alloc, Gen >::operator= ( const SequenceImplementation< Key, OtherAlloc, Gen > &  aSeq )

private

Generalized opy operator.

Template Parameters

OtherAlloc

The other gum::SequenceImplementation allocator.

Parameters

aSeq	The sequence to copy.

Returns

Returns a ref to this.

operator=() [3/5]

template<typename Key, typename Alloc, bool Gen>

INLINE SequenceImplementation< Key, Alloc, Gen > & gum::SequenceImplementation< Key, Alloc, Gen >::operator= ( SequenceImplementation< Key, Alloc, Gen > &&  aSeq )

private

Move operator.

Parameters

aSeq	The sequence to move.

Returns

Returns a ref to this.

Definition at line 388 of file sequence_tpl.h.

                                                                     {
    // avoid self assignment
    if (&aSeq != this) {
      __h = std::move(aSeq.__h);
      __v = std::move(aSeq.__v);
      __update_end();
    }

    return *this;
  }

operator=() [4/5]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE SequenceImplementation< Key, Alloc, Gen >& gum::SequenceImplementation< Key, Alloc, Gen >::operator=

(

const SequenceImplementation< Key, OtherAlloc, Gen > &

aSeq

)

Definition at line 379 of file sequence_tpl.h.

                                                                               {
    __copy(aSeq);   // performs the __update_end ()
    return *this;
  }

operator=() [5/5]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

INLINE SequenceImplementation< Key, Alloc, true >& gum::SequenceImplementation< Key, Alloc, Gen >::operator=

(

const SequenceImplementation< Key, OtherAlloc, true > &

aSeq

)

Definition at line 810 of file sequence_tpl.h.

                                                                                {
    __copy(aSeq);
    return *this;
  }

operator==() [1/2]

template<typename Key, typename Alloc , bool Gen>

template<typename OtherAlloc >

bool gum::SequenceImplementation< Key, Alloc, Gen >::operator==

(

const SequenceImplementation< Key, OtherAlloc, Gen > &

k

)

const

Returns true if the content of k equals that of *this.

Note that two sequences are equal if and only if they contain the same Keys (using Key::operator==) in the same order.

Template Parameters

OtherAlloc

The other gum::SequenceImplementation allocator.

Parameters

k	The other gum::SequenceImplementation. Returns true if both gum::SequenceImplementation are equal.

Definition at line 596 of file sequence_tpl.h.

                                                                                 {
    if (size() != k.size())
      return false;
    else {
      for (Idx i = 0; i < size(); ++i)
        if (*__v[i] != *(k.__v[i])) return false;
    }

    return true;
  }

operator==() [2/2]

template<typename Key, typename Alloc, bool Gen>

template<typename OtherAlloc >

bool gum::SequenceImplementation< Key, Alloc, Gen >::operator==

(

const SequenceImplementation< Key, OtherAlloc, true > &

k

)

const

Definition at line 996 of file sequence_tpl.h.

                                                                                  {
    if (size() != k.size())
      return false;
    else {
      for (Idx i = 0; i < size(); ++i)
        if (__v[i] != k.__v[i]) return false;
    }

    return true;
  }

operator>>()

template<typename Key, typename Alloc , bool Gen>

INLINE SequenceImplementation< Key, Alloc, true > & gum::SequenceImplementation< Key, Alloc >::operator>>

(

const Key &

k

)

Remove k in the sequence (synonym for erase).

If the element cannot be found, the function does nothing. In particular, it throws no exception.

Parameters

k	The key we wish to remove.

Returns

Returns this gum::SequenceImplementation.

Definition at line 493 of file sequence_tpl.h.

                                                                       {
    erase(k);
    return *this;
  }

operator[]()

template<typename Key , typename Alloc >

INLINE const Key & gum::SequenceImplementation< Key, Alloc >::operator[]

(

Idx

i

)

const

Returns the element at position i (synonym for atPos).

Parameters

i	The position of the element to return.

Returns

Returns the element at position i.

Exceptions

OutOfBounds

Raised if the element does not exist.

Definition at line 512 of file sequence_tpl.h.

                                            {
    return atPos(i);
  }

pos()

template<typename Key, typename Alloc , bool Gen>

INLINE Idx gum::SequenceImplementation< Key, Alloc >::pos

(

const Key &

key

)

const

Returns the position of the object passed in argument (if it exists).

Parameters

key	The element for which the positon is returned.

Returns

Returns the position of the object passed in argument.

Exceptions

NotFound

Raised if the element does not exist.

Definition at line 518 of file sequence_tpl.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__checkElimOrder(), gum::prm::SVE< GUM_SCALAR >::__checkElimOrder(), and gum::learning::genericBNLearner::__learnDAG().

                                                                                {
    return __h[key];
  }

Here is the caller graph for this function:

rbegin()

template<typename Key , typename Alloc >

INLINE SequenceIterator< Key > gum::SequenceImplementation< Key, Alloc >::rbegin

(

)

const

Returns an unsafe rbegin iterator.

Returns

Returns an unsafe rbegin iterator.

Definition at line 671 of file sequence_tpl.h.

                                                                 {
    SequenceIterator< Key > it{*this};
    it.__setPos(size() - 1);
    return it;
  }

rbeginSafe()

template<typename Key , typename Alloc >

INLINE SequenceIteratorSafe< Key > gum::SequenceImplementation< Key, Alloc >::rbeginSafe

(

)

const

Returns a safe rbegin iterator.

Returns

Returns a safe rbegin iterator.

Definition at line 641 of file sequence_tpl.h.

                                                                     {
    SequenceIteratorSafe< Key > it{*this};
    it.__setPos(size() - 1);
    return it;
  }

rend()

template<typename Key , typename Alloc >

INLINE const SequenceIterator< Key > & gum::SequenceImplementation< Key, Alloc >::rend ( ) const

noexcept

Returns the unsafe rend iterator.

Returns

Returns the unsafe rend iterator.

Definition at line 680 of file sequence_tpl.h.

                                                                              {
    return __rend_safe;
  }

rendSafe()

template<typename Key , typename Alloc >

INLINE const SequenceIteratorSafe< Key > & gum::SequenceImplementation< Key, Alloc >::rendSafe ( ) const

noexcept

Returns the safe rend iterator.

Returns

Returns the safe rend iterator.

Definition at line 650 of file sequence_tpl.h.

                                                                                  {
    return __rend_safe;
  }

resize()

template<typename Key , typename Alloc >

INLINE void gum::SequenceImplementation< Key, Alloc >::resize

(

Size

new_size

)

Modifies the size of the internal structures of the sequence.

This function is provided for optimization issues. When you know you will have to insert elements into the sequence, it may be faster to use this function prior to the additions because it will change once and for all the sizes of all the internal containers. Note that if you provide a size that is smaller than the number of elements of the sequence, the function will not modify anything.

Parameters

new_size

The internal structure new size.

Definition at line 686 of file sequence_tpl.h.

Referenced by gum::operator<<(), and gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::resize().

                                                                             {
    if (new_size < __h.size()) return;

    __h.resize(new_size);
    __v.reserve(new_size);
  }

Here is the caller graph for this function:

setAtPos() [1/2]

template<typename Key, typename Alloc , bool Gen>

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::setAtPos	(	Idx	i,
		const Key &	newKey
	)

Change the value.

Parameters

i	The element's position.
newKey	The element's new value.

Exceptions

NotFound	Raised if the element does not exist.
DuplicateElement	Raised if newKey alreay exists.

Definition at line 525 of file sequence_tpl.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

                                                                            {
    if (i >= __h.size()) { GUM_ERROR(NotFound, "index too large"); }

    Key& new_key = const_cast< Key& >(__h.insert(newKey, i).first);
    __h.erase(*(__v[i]));
    __v[i] = &new_key;
  }

Here is the caller graph for this function:

setAtPos() [2/2]

template<typename Key, typename Alloc , bool Gen>

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::setAtPos	(	Idx	i,
		Key &&	newKey
	)

Change the value.

Parameters

i	The element's position.
newKey	The element's new value.

Exceptions

NotFound	Raised if the element does not exist.
DuplicateElement	Raised if newKey alreay exists.

Definition at line 536 of file sequence_tpl.h.

                                                                                {
    if (i >= __h.size()) { GUM_ERROR(NotFound, "index too large"); }

    Key& new_key = const_cast< Key& >(__h.insert(std::move(newKey), i).first);
    __h.erase(*(__v[i]));
    __v[i] = &new_key;
  }

size()

template<typename Key , typename Alloc >

INLINE Size gum::SequenceImplementation< Key, Alloc >::size ( ) const

noexcept

Returns the size of the sequence.

Returns

Returns the size of the sequence.

Definition at line 38 of file sequence_tpl.h.

Referenced by gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::__copy(), gum::prm::StructuredInference< GUM_SCALAR >::__removeBarrenNodes(), gum::DiGraph::__topologicalOrder(), gum::GibbsOperator< GUM_SCALAR >::__updateSamplingNodes(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::empty(), gum::GibbsOperator< GUM_SCALAR >::nextSample(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator==(), and gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::size().

                                                                             {
    return __h.size();
  }

Here is the caller graph for this function:

swap()

template<typename Key , typename Alloc >

INLINE void gum::SequenceImplementation< Key, Alloc >::swap	(	Idx	i,
		Idx	j
	)

Swap index.

Parameters

i	The index of the first elt to swap.
j	The index of the other elt to swap.

Definition at line 547 of file sequence_tpl.h.

                                                                          {
    if (i == j) return;

    Key& ki = const_cast< Key& >(atPos(i));
    Key& kj = const_cast< Key& >(atPos(j));

    __h[ki] = j;
    __h[kj] = i;

    __v[i] = &kj;
    __v[j] = &ki;
  }

toString()

template<typename Key , typename Alloc >

std::string gum::SequenceImplementation< Key, Alloc >::toString

(

)

const

Displays the content of the sequence.

Returns

The content of the sequence.

Definition at line 574 of file sequence_tpl.h.

Referenced by gum::operator<<().

                                                                      {
    std::stringstream stream;
    stream << "[";

    if (!__h.empty()) {
      stream << 0 << ":" << *__v[0];

      for (Idx i = 1; i < __h.size(); ++i) {
        stream << " - " << i << ":" << *__v[i];
      }
    }

    stream << "]";

    std::string res = stream.str();
    return res;
  }

Here is the caller graph for this function:

Friends And Related Function Documentation

SequenceImplementation

template<typename Key, typename Alloc, bool Gen>

template<typename K , typename A , bool >

friend class SequenceImplementation

friend

Friends to speed up access.

Definition at line 94 of file sequence.h.

Sequence< Key, Alloc >

template<typename Key, typename Alloc, bool Gen>

friend class Sequence< Key, Alloc >

friend

Friends to speed up access.

Definition at line 96 of file sequence.h.

SequenceIteratorSafe< Key >

template<typename Key, typename Alloc, bool Gen>

friend class SequenceIteratorSafe< Key >

friend

Friends to speed up access.

Definition at line 95 of file sequence.h.

Member Data Documentation

__end_safe

template<typename Key, typename Alloc, bool Gen>

SequenceIteratorSafe< Key > gum::SequenceImplementation< Key, Alloc, Gen >::__end_safe

private

Stores the end iterator for fast access.

Definition at line 510 of file sequence.h.

__h

template<typename Key, typename Alloc, bool Gen>

HashTable< Key, Idx, Alloc > gum::SequenceImplementation< Key, Alloc, Gen >::__h

private

Keep track of the position of the element in v (for fast retrieval).

Definition at line 500 of file sequence.h.

Referenced by gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator=().

__rend_safe

template<typename Key, typename Alloc, bool Gen>

SequenceIteratorSafe< Key > gum::SequenceImplementation< Key, Alloc, Gen >::__rend_safe

private

Stores the rend iterator for fast access.

Definition at line 513 of file sequence.h.

__v

template<typename Key, typename Alloc, bool Gen>

std::vector< Key*, typename Alloc::template rebind< Key* >::other > gum::SequenceImplementation< Key, Alloc, Gen >::__v

private

The set of the elements stored into the sequence.

Definition at line 503 of file sequence.h.

Referenced by gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::__copy(), gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator=(), and gum::SequenceImplementation< gum::prm::PRMClassElement< double > *, std::allocator< gum::prm::PRMClassElement< double > *>, std::is_scalar< gum::prm::PRMClassElement< double > *>::value >::operator==().

---

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

• agrum/core/sequence.h
• agrum/core/sequence_tpl.h