gum::Sequence< Key, Alloc > Class Template Reference

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

#include <agrum/tools/core/sequence.h>

Inheritance diagram for gum::Sequence< Key, Alloc >:

Collaboration diagram for gum::Sequence< Key, Alloc >:

Public Member Functions
template<typename OtherAlloc >
INLINE	Sequence (const Sequence< Key, OtherAlloc > &aSeq)
template<typename OtherAlloc >
INLINE Sequence< Key, Alloc > &	operator= (const Sequence< Key, OtherAlloc > &aSeq)
bool	operator== (const SequenceImplementation< Key, OtherAlloc, true > &k) const
INLINE bool	operator!= (const SequenceImplementation< Key, OtherAlloc, Gen > &k) const
INLINE bool	operator!= (const SequenceImplementation< Key, OtherAlloc, true > &k) const
INLINE void	emplace (Args &&... args)
INLINE void	_copy_ (const SequenceImplementation< Key, OtherAlloc, Gen > &aSeq)
INLINE void	_copy_ (const SequenceImplementation< Key, OtherAlloc, true > &aSeq)
Constructors / Destructors
	Sequence (Size size_param=HashTableConst::default_size)
	Default constructor. More...
	Sequence (std::initializer_list< Key > list)
	Initializer list constructor. More...
	Sequence (const Sequence< Key, Alloc > &aSeq)
	Copy constructor. More...
template<typename OtherAlloc >
	Sequence (const Sequence< Key, OtherAlloc > &aSeq)
	Generalised copy constructor. More...
	Sequence (Sequence< Key, Alloc > &&aSeq)
	Move constructor. More...
	~Sequence () noexcept
	Class destructor. More...
Operators
Sequence< Key, Alloc > &	operator= (const Sequence< Key, Alloc > &aSeq)
	Copy operator. More...
template<typename OtherAlloc >
Sequence< Key, Alloc > &	operator= (const Sequence< Key, OtherAlloc > &aSeq)
	Generalized opy operator. More...
Sequence< Key, Alloc > &	operator= (Sequence< Key, Alloc > &&aSeq)
	Move operator. More...
Accessors / Modifiers
template<typename OtherAlloc >
Set< Key, Alloc >	diffSet (const Sequence< Key, OtherAlloc > &seq) const
	Difference between two sequences as a Set<Key> = this \ seq. 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...
bool	operator== (const SequenceImplementation< Key, OtherAlloc, Gen > &k) const
	Returns true if the content of k equals that of *this. More...
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...
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	Implementation = SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >
	The gum::Sequence implementation. More...
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...

Detailed Description

template<typename Key, typename Alloc = std::allocator< Key >>
class gum::Sequence< Key, Alloc >

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

A gum::Sequence<Key> is quite similar to a std::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 gum::Sequence<Key> 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.

Usage example:

// creation of a sequence
Sequence<int> seq { 1, 2, 3, 4 };
Sequence<string> seq2;

// creation of safe iterators
SequenceIteratorSafe<int> iter1 = seq.beginSafe (); // points to 1
SequenceIteratorSafe<int> iter2 = iter1;
SequenceIteratorSafe<int> iter3 = std::move ( iter1 );

// creation of unsafe iterators
SequenceIterator<int> xiter1 = seq.begin (); // points to 1
SequenceIterator<int> xiter2 = xiter1;
SequenceIterator<int> xiter3 = std::move ( xiter1 );

// parsing the sequence
for ( auto iter = seq.begin (); iter != seq.end (); ++iter )
  std::cout << *iter << std::endl;
for ( auto iter = seq.rbegin (); iter != seq.rend (); --iter )
  std::cout << *iter << std::endl;
for ( auto iter = seq.begin (); iter != seq.end (); ++iter )
  std::cout << iter->size () << std::endl;

Template Parameters

Key	The elements type stored in the sequence.
Alloc	The values allocator.

Definition at line 1017 of file sequence.h.

Member Typedef Documentation

allocator_type

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::allocator_type = Alloc

Types for STL compliance.

Definition at line 1028 of file sequence.h.

const_iterator

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::const_iterator = SequenceIterator< Key >

Types for STL compliance.

Definition at line 1030 of file sequence.h.

const_iterator_safe

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::const_iterator_safe = SequenceIteratorSafe< Key >

Types for STL compliance.

Definition at line 1032 of file sequence.h.

const_pointer

template<typename Key, typename Alloc = std::allocator< Key >>

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

Types for STL compliance.

Definition at line 1025 of file sequence.h.

const_reference

template<typename Key, typename Alloc = std::allocator< Key >>

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

Types for STL compliance.

Definition at line 1023 of file sequence.h.

difference_type

template<typename Key, typename Alloc = std::allocator< Key >>

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

Types for STL compliance.

Definition at line 1027 of file sequence.h.

Implementation

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::Implementation = SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >

The gum::Sequence implementation.

Definition at line 1036 of file sequence.h.

iterator

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::iterator = SequenceIterator< Key >

Types for STL compliance.

Definition at line 1029 of file sequence.h.

iterator_safe

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::iterator_safe = SequenceIteratorSafe< Key >

Types for STL compliance.

Definition at line 1031 of file sequence.h.

pointer

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::pointer = Key*

Types for STL compliance.

Definition at line 1024 of file sequence.h.

reference

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::reference = Key&

Types for STL compliance.

Definition at line 1022 of file sequence.h.

size_type

template<typename Key, typename Alloc = std::allocator< Key >>

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

Types for STL compliance.

Definition at line 1026 of file sequence.h.

value_type

template<typename Key, typename Alloc = std::allocator< Key >>

using gum::Sequence< Key, Alloc >::value_type = Key

Types for STL compliance.

Definition at line 1021 of file sequence.h.

Constructor & Destructor Documentation

Sequence() [1/6]

template<typename Key , typename Alloc >

INLINE gum::Sequence< Key, Alloc >::Sequence

(

Size

size_param = HashTableConst::default_size

)

Default constructor.

Parameters

size_param

The intial size of the gum::SequenceImplementation.

Definition at line 1056 of file sequence_tpl.h.

                                                         :
      SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >(size_param) {
    GUM_CONSTRUCTOR(Sequence);
  }

Sequence() [2/6]

template<typename Key, typename Alloc >

INLINE gum::Sequence< Key, Alloc >::Sequence

(

std::initializer_list< Key >

list

)

Initializer list constructor.

Parameters

list	The initializer list.

Definition at line 1063 of file sequence_tpl.h.

                                                                         :
      SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >(list) {
    // for debugging purposes
    GUM_CONSTRUCTOR(Sequence);
  }

Sequence() [3/6]

template<typename Key, typename Alloc>

INLINE gum::Sequence< Key, Alloc >::Sequence

(

const Sequence< Key, Alloc > &

aSeq

)

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 1071 of file sequence_tpl.h.

                                                                            :
      SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >(aSeq) {
    // for debugging purposes
    GUM_CONS_CPY(Sequence);
  }

Sequence() [4/6]

template<typename Key, typename Alloc = std::allocator< Key >>

template<typename OtherAlloc >

gum::Sequence< Key, Alloc >::Sequence

(

const Sequence< Key, OtherAlloc > &

aSeq

)

Generalised copy constructor.

Template Parameters

OtherAlloc

The other gum::Sequence 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.

Sequence() [5/6]

template<typename Key, typename Alloc>

INLINE gum::Sequence< Key, Alloc >::Sequence

(

Sequence< Key, Alloc > &&

aSeq

)

Move constructor.

Parameters

aSeq	The gum::Sequence to move/

Definition at line 1088 of file sequence_tpl.h.

                                                                       :
      SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >(std::move(aSeq)) {
    // for debugging purposes
    GUM_CONS_MOV(Sequence);
  }

~Sequence()

template<typename Key , typename Alloc >

INLINE gum::Sequence< Key, Alloc >::~Sequence ( )

noexcept

Class destructor.

Definition at line 1096 of file sequence_tpl.h.

                                                    {
    // for debugging purposes
    GUM_DESTRUCTOR(Sequence);
  }

Sequence() [6/6]

template<typename Key, typename Alloc = std::allocator< Key >>

template<typename OtherAlloc >

INLINE gum::Sequence< Key, Alloc >::Sequence

(

const Sequence< Key, OtherAlloc > &

aSeq

)

Definition at line 1080 of file sequence_tpl.h.

                                                                                 :
      SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >(aSeq) {
    // for debugging purposes
    GUM_CONS_CPY(Sequence);
  }

Member Function Documentation

_copy_() [1/2]

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

inherited

Definition at line 273 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/2]

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

inherited

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

atPos()

INLINE const Key & gum::SequenceImplementation< Key, Alloc >::atPos ( Idx  i ) const

inherited

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 483 of file sequence_tpl.h.

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

    return *(_v_[i]);
  }

back()

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

inherited

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 546 of file sequence_tpl.h.

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

begin()

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

inherited

Returns an unsafe begin iterator.

Returns

Returns an unsafe begin iterator.

Definition at line 631 of file sequence_tpl.h.

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

beginSafe()

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

inherited

Returns a safe begin iterator.

Returns

Returns a safe begin iterator.

Definition at line 603 of file sequence_tpl.h.

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

clear()

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

inherited

Clear the sequence.

Definition at line 264 of file sequence_tpl.h.

                                                               {
    _h_.clear();
    _v_.clear();
    _update_end_();
  }

diffSet()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

Set< Key, Alloc > gum::Sequence< Key, Alloc >::diffSet

(

const Sequence< Key, OtherAlloc > &

seq

)

const

Difference between two sequences as a Set<Key> = this \ seq.

Parameters

seq	The gum::Sequence to substract of this.

Returns

Returns the set difference : *this \ seq.

Definition at line 1128 of file sequence_tpl.h.

                                                                                                {
    Set< Key, Alloc > res;

    for (iterator iter = this->begin(); iter != this->end(); ++iter) {
      if (!seq.exists(*iter)) res << *iter;
    }

    return res;
  }

emplace() [1/2]

void gum::SequenceImplementation< Key, Alloc, Gen >::emplace ( Args &&...  args )

inherited

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]

INLINE void gum::SequenceImplementation< Key, Alloc >::emplace ( Args &&...  args )

inherited

Definition at line 412 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()

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

noexceptinherited

Return true if empty.

Returns

Return true if empty.

Definition at line 43 of file sequence_tpl.h.

                                                                              {
    return _h_.empty();
  }

end()

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

noexceptinherited

Returns the unsafe end iterator.

Returns

Returns the unsafe end iterator.

Definition at line 638 of file sequence_tpl.h.

                                                                             {
    return _end_safe_;
  }

endSafe()

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

noexceptinherited

Returns the safe end iterator.

Returns

Returns the safe end iterator.

Definition at line 610 of file sequence_tpl.h.

                                                                                 {
    return _end_safe_;
  }

erase() [1/2]

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::erase ( const Key &  k )

inherited

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 437 of file sequence_tpl.h.

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

erase() [2/2]

INLINE void gum::SequenceImplementation< Key, Alloc >::erase ( const iterator_safe &  k )

inherited

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 457 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()

INLINE bool gum::SequenceImplementation< Key, Alloc >::exists ( const Key &  k ) const

inherited

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 387 of file sequence_tpl.h.

                                                                                  {
    return _h_.exists(k);
  }

front()

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

inherited

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 540 of file sequence_tpl.h.

                                                                           {
    return atPos(0);
  }

insert() [1/2]

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::insert ( const Key &  k )

inherited

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 393 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(k, _h_.size()).first);
    _v_.push_back(&new_key);
    _update_end_();
  }

insert() [2/2]

INLINE void gum::SequenceImplementation< Key, Alloc, Gen >::insert ( Key &&  k )

inherited

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 402 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]

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

inherited

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]

INLINE bool gum::SequenceImplementation< Key, Alloc, Gen >::operator!= ( const SequenceImplementation< Key, OtherAlloc, Gen > &  k ) const

inherited

Definition at line 588 of file sequence_tpl.h.

                                                                    {
    return !operator==(k);
  }

operator!=() [3/3]

INLINE bool gum::SequenceImplementation< Key, Alloc, Gen >::operator!= ( const SequenceImplementation< Key, OtherAlloc, true > &  k ) const

inherited

Definition at line 971 of file sequence_tpl.h.

                                                                     {
    return !operator==(k);
  }

operator<<() [1/2]

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

inherited

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 422 of file sequence_tpl.h.

                                                                       {
    insert(k);
    return *this;
  }

operator<<() [2/2]

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

inherited

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 430 of file sequence_tpl.h.

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

operator=() [1/4]

template<typename Key, typename Alloc>

INLINE Sequence< Key, Alloc > & gum::Sequence< Key, Alloc >::operator=

(

const Sequence< Key, Alloc > &

aSeq

)

Copy operator.

Parameters

aSeq	The sequence to copy.

Returns

Returns a ref to this.

Definition at line 1104 of file sequence_tpl.h.

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

operator=() [2/4]

template<typename Key, typename Alloc = std::allocator< Key >>

template<typename OtherAlloc >

Sequence< Key, Alloc >& gum::Sequence< Key, Alloc >::operator=

(

const Sequence< Key, OtherAlloc > &

aSeq

)

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/4]

template<typename Key, typename Alloc = std::allocator< Key >>

template<typename OtherAlloc >

INLINE Sequence< Key, Alloc >& gum::Sequence< Key, Alloc >::operator=

(

const Sequence< Key, OtherAlloc > &

aSeq

)

Definition at line 1113 of file sequence_tpl.h.

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

operator=() [4/4]

template<typename Key, typename Alloc>

INLINE Sequence< Key, Alloc > & gum::Sequence< Key, Alloc >::operator=

(

Sequence< Key, Alloc > &&

aSeq

)

Move operator.

Parameters

aSeq	The sequence to move.

Returns

Returns a ref to this.

Definition at line 1120 of file sequence_tpl.h.

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

operator==() [1/2]

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

inherited

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 573 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]

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

inherited

Definition at line 956 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>>()

INLINE SequenceImplementation< Key, Alloc, true > & gum::SequenceImplementation< Key, Alloc >::operator>> ( const Key &  k )

inherited

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 476 of file sequence_tpl.h.

                                                                       {
    erase(k);
    return *this;
  }

operator[]()

INLINE const Key & gum::SequenceImplementation< Key, Alloc >::operator[] ( Idx  i ) const

inherited

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 493 of file sequence_tpl.h.

                                                                                     {
    return atPos(i);
  }

pos()

INLINE Idx gum::SequenceImplementation< Key, Alloc >::pos ( const Key &  key ) const

inherited

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 499 of file sequence_tpl.h.

                                                                                {
    return _h_[key];
  }

rbegin()

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

inherited

Returns an unsafe rbegin iterator.

Returns

Returns an unsafe rbegin iterator.

Definition at line 644 of file sequence_tpl.h.

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

rbeginSafe()

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

inherited

Returns a safe rbegin iterator.

Returns

Returns a safe rbegin iterator.

Definition at line 616 of file sequence_tpl.h.

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

rend()

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

noexceptinherited

Returns the unsafe rend iterator.

Returns

Returns the unsafe rend iterator.

Definition at line 653 of file sequence_tpl.h.

                                                                              {
    return _rend_safe_;
  }

rendSafe()

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

noexceptinherited

Returns the safe rend iterator.

Returns

Returns the safe rend iterator.

Definition at line 625 of file sequence_tpl.h.

                                                                                  {
    return _rend_safe_;
  }

resize()

INLINE void gum::SequenceImplementation< Key, Alloc >::resize ( Size  new_size )

inherited

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 659 of file sequence_tpl.h.

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

    _h_.resize(new_size);
    _v_.reserve(new_size);
  }

setAtPos() [1/2]

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

inherited

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 505 of file sequence_tpl.h.

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

setAtPos() [2/2]

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

inherited

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 515 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()

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

noexceptinherited

Returns the size of the sequence.

Returns

Returns the size of the sequence.

Definition at line 37 of file sequence_tpl.h.

                                                                             {
    return _h_.size();
  }

swap()

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

inherited

Swap index.

Parameters

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

Definition at line 525 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()

std::string gum::SequenceImplementation< Key, Alloc >::toString ( ) const

inherited

Displays the content of the sequence.

Returns

The content of the sequence.

Definition at line 552 of file sequence_tpl.h.

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

---

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

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