Representation of a setA Set is a structure that contains arbitrary elements. More...

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

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

Public Member Functions
template<typename OtherAlloc >
INLINE	Set (const Set< Key, OtherAlloc > &s)

template<typename OtherAlloc >
INLINE bool	operator!= (const Set< Key, OtherAlloc > &s2) const

template<typename OtherAlloc >
INLINE bool	isProperSubsetOf (const Set< Key, OtherAlloc > &s) const

template<typename OtherAlloc >
INLINE bool	isProperSupersetOf (const Set< Key, OtherAlloc > &s) const

template<typename OtherAlloc >
INLINE bool	isSubsetOrEqual (const Set< Key, OtherAlloc > &s) const

template<typename OtherAlloc >
INLINE bool	isSupersetOrEqual (const Set< Key, OtherAlloc > &s) const

template<typename... Args>
INLINE void	emplace (Args &&... args)

Constructors / Destructors
	Set (Size capacity=HashTableConst::default_size, bool resize_policy=true)
	Default constructor. More...

	Set (std::initializer_list< Key > list)
	Initializer list constructor. More...

	Set (const Set< Key, Alloc > &aHT)
	Copy constructor. More...

template<typename OtherAlloc >
	Set (const Set< Key, OtherAlloc > &aHT)
	Generalized copy constructor. More...

	Set (Set< Key, Alloc > &&aHT)
	Move constructor. More...

	~Set ()
	Class destructor. More...

Operators
Set< Key, Alloc > &	operator= (const Set< Key, Alloc > &from)
	Copy operator. More...

template<typename OtherAlloc >
Set< Key, Alloc > &	operator= (const Set< Key, OtherAlloc > &from)
	Generalized copy operator. More...

Set< Key, Alloc > &	operator= (Set< Key, Alloc > &&from)
	Move operator. More...

template<typename OtherAlloc >
bool	operator== (const Set< Key, OtherAlloc > &s2) const
	Mathematical equality between two sets. More...

template<typename OtherAlloc >
bool	operator!= (const Set< Key, OtherAlloc > &s2) const
	Mathematical inequality between two sets. More...

template<typename OtherAlloc >
const Set< Key, Alloc > &	operator*= (const Set< Key, OtherAlloc > &s2)
	Intersection update operator. More...

template<typename OtherAlloc >
Set< Key, Alloc >	operator* (const Set< Key, OtherAlloc > &s2) const
	Intersection operator. More...

template<typename OtherAlloc >
const Set< Key, Alloc > &	operator+= (const Set< Key, OtherAlloc > &s2)
	Union update operator. More...

template<typename OtherAlloc >
Set< Key, Alloc >	operator+ (const Set< Key, OtherAlloc > &s2) const
	Union operator. More...

template<typename OtherAlloc >
Set< Key, Alloc >	operator- (const Set< Key, OtherAlloc > &s2) const
	Disjunction operator. More...

Set< Key, Alloc > &	operator<< (const Key &k)
	Adds a new element to the set (alias for insert). More...

Set< Key, Alloc > &	operator<< (Key &&k)
	Adds a new element to the set (alias for insert). More...

Set< Key, Alloc > &	operator>> (const Key &k)
	Removes an element from the set (alias for erase). More...

Accessors / Modifiers
void	insert (const Key &k)
	Inserts a new element into the set. More...

void	insert (Key &&k)
	Inserts a new element into the set. More...

template<typename... Args>
void	emplace (Args &&... args)
	Emplace a new element in the set. More...

void	erase (const Key &k)
	Erases an element from the set. More...

void	erase (const iterator_safe &k)
	Erases an element from the set. More...

void	clear ()
	Removes all the elements, if any, from the set. More...

Size	size () const noexcept
	Returns the number of elements in the set. More...

bool	contains (const Key &k) const
	Indicates whether a given elements belong to the set. More...

template<typename OtherAlloc >
bool	isProperSubsetOf (const Set< Key, OtherAlloc > &s) const

template<typename OtherAlloc >
bool	isProperSupersetOf (const Set< Key, OtherAlloc > &s) const

template<typename OtherAlloc >
bool	isSubsetOrEqual (const Set< Key, OtherAlloc > &s) const

template<typename OtherAlloc >
bool	isSupersetOrEqual (const Set< Key, OtherAlloc > &s) const

bool	exists (const Key &k) const
	Indicates whether a given elements belong to the set. More...

bool	empty () const noexcept
	Indicates whether the set is the empty set. More...

std::string	toString () const
	Prints the content of the set. More...

Fine tuning
Size	capacity () const
	Returns the capacity of the underlying hash table containing the set. More...

void	resize (Size new_capacity)
	Changes the size of the underlying hash table containing the set. More...

void	setResizePolicy (const bool new_policy)
	Enables the user to change dynamically the resizing policy of the underlying hash table. More...

bool	resizePolicy () const
	Returns the current resizing policy of the underlying hash table. More...

Mapper
template<typename NewKey , typename NewAlloc = typename Alloc::template rebind< NewKey >::other>
HashTable< Key, NewKey, NewAlloc >	hashMap (NewKey(*f)(const Key &), Size capacity=0) const
	Creates a hashtable of NewKey from the set. More...

template<typename NewKey , typename NewAlloc = typename Alloc::template rebind< NewKey >::other>
HashTable< Key, NewKey, NewAlloc >	hashMap (const NewKey &val, Size size=0) const
	Creates a hash table of NewKey from the set. More...

template<typename NewKey , typename NewAlloc = typename Alloc::template rebind< NewKey >::other>
List< NewKey, NewAlloc >	listMap (NewKey(*f)(const Key &)) const
	A method to create a List of NewKey from the set. 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 = SetIterator< Key >
	Types for STL compliance. More...

using	const_iterator = SetIterator< Key >
	Types for STL compliance. More...

using	iterator_safe = SetIteratorSafe< Key >
	Types for STL compliance. More...

using	const_iterator_safe = SetIteratorSafe< Key >
	Types for STL compliance. More...

Friends

class	SetIterator< Key >
	Friends to speed up access. More...

class	SetIteratorSafe< Key >
	Friends to speed up access. More...

template<typename K , typename A >
class	Set
	Friends to speed up access. More...

Iterators
iterator_safe	beginSafe () const
	The usual safe begin iterator to parse the set. More...

const_iterator_safe	cbeginSafe () const
	The usual safe begin iterator to parse the set. More...

const iterator_safe &	endSafe () const noexcept
	The usual safe end iterator to parse the set. More...

const const_iterator_safe &	cendSafe () const noexcept
	The usual safe end iterator to parse the set. More...

iterator	begin () const
	The usual unsafe begin iterator to parse the set. More...

const_iterator	cbegin () const
	The usual unsafe begin iterator to parse the set. More...

const iterator &	end () const noexcept
	The usual unsafe end iterator to parse the set. More...

const const_iterator &	cend () const noexcept
	The usual unsafe end iterator to parse the set. More...

static const iterator &	end4Statics ()
	Returns the end iterator for other classes' statics (read the detailed description of this method). More...

static const const_iterator &	constEnd4Statics ()
	Returns the end iterator for other classes' statics (read the detailed description of this method). More...

static const iterator_safe &	endSafe4Statics ()
	Returns the end iterator for other classes' statics (read the detailed description of this method). More...

static const const_iterator_safe &	constEndSafe4Statics ()
	Returns the end iterator for other classes' statics (read the detailed description of this method). More...

Detailed Description

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

Representation of a set

A Set is a structure that contains arbitrary elements.

Note that, as in mathematics, an element cannot appear twice in a given set. Sets have unsafe and safe iterators. The safe iterators (SetIteratorSafe<> a.k.a. Set<>::iterator_safe are slightly slower than the unsafe ones (SetIterator<> a.k.a. Set<>::iterator) but they guarantee that even if they point to a deleted element, using their operators ++ or * cannot produce a segfault. In such cases, they simply raise an exception. On the contrary, unsafe iterators should never be used on elements that can be deleted because, as in the STL, they will most probably produce a segfault.

Usage example:: // creation of a set with 10 elements
Set<int> set;
for (int i = 0; i< 10; ++i)
set<<i;
Set<int> set2 { 1, 2, 3 };
// parse the set
for (const auto iter = set.begin (); iter != set.end (); ++iter) {
// display the values
cerr << *iter << endl;
}
// use an iterator to point the element we wish to erase
Set<int>::iterator iter = set.begin ();
set.erase ( iter );
// check whether two iterators point toward the same element
Set<int>::iterator iter1 = set.begin();
Set<int>::iterator iter2 = set.end();
if (iter1 != iter2)
cerr << "iter1 and iter2 point toward different elements";

Template Parameters

Key	The elements type.
Alloc	The elements allocator.

Definition at line 164 of file set.h.

Member Typedef Documentation

◆ allocator_type

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

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

Types for STL compliance.

Definition at line 175 of file set.h.

◆ const_iterator

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

using gum::Set< Key, Alloc >::const_iterator = SetIterator< Key >

Types for STL compliance.

Definition at line 177 of file set.h.

◆ const_iterator_safe

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

using gum::Set< Key, Alloc >::const_iterator_safe = SetIteratorSafe< Key >

Types for STL compliance.

Definition at line 179 of file set.h.

◆ const_pointer

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

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

Types for STL compliance.

Definition at line 172 of file set.h.

◆ const_reference

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

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

Types for STL compliance.

Definition at line 170 of file set.h.

◆ difference_type

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

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

Types for STL compliance.

Definition at line 174 of file set.h.

◆ iterator

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

using gum::Set< Key, Alloc >::iterator = SetIterator< Key >

Types for STL compliance.

Definition at line 176 of file set.h.

◆ iterator_safe

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

using gum::Set< Key, Alloc >::iterator_safe = SetIteratorSafe< Key >

Types for STL compliance.

Definition at line 178 of file set.h.

◆ pointer

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

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

Types for STL compliance.

Definition at line 171 of file set.h.

◆ reference

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

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

Types for STL compliance.

Definition at line 169 of file set.h.

◆ size_type

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

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

Types for STL compliance.

Definition at line 173 of file set.h.

◆ value_type

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

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

Types for STL compliance.

Definition at line 168 of file set.h.

Constructor & Destructor Documentation

◆ Set() [1/7]

template<typename Key , typename Alloc >

INLINE gum::Set< Key, Alloc >::Set	(	Size	capacity = `HashTableConst::default_size`,
		bool	resize_policy = `true`
	)

explicit

Default constructor.

Sets rely on hashtables to store their items. The optional parameters of this constructor enable a fine memory management of these hashtables.

Parameters

capacity	The number of slots allocated to the hashtable (see the HashTable default constructor)
resize_policy	Enables the hashtable to resize itself automatically when its number of elements is sufficiently high that it induces slow retrievals of elements.

Definition at line 318 of file set_tpl.h.

                                                                  :
       // create the hash table without key uniqueness policy (as we will
       // check
       // ourselves the uniqueness of Keys before inserting new elements)
       inside__(capacity, resize_policy, false) {
     GUM_CONSTRUCTOR(Set);
 
     // make sure the end() iterator is constructed properly
     endSafe4Statics();
     end4Statics();
   }

◆ Set() [2/7]

template<typename Key, typename Alloc >

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

Initializer list constructor.

Parameters

list	The initializer list.

Definition at line 332 of file set_tpl.h.

                                                                :
       inside__(Size(list.size()) / 2, true, false) {
     GUM_CONSTRUCTOR(Set);
     for (const auto& elt: list) {
       insert(elt);
     }
 
     // make sure the end() iterator is constructed properly
     endSafe4Statics();
     end4Statics();
   }

◆ Set() [3/7]

template<typename Key, typename Alloc>

INLINE gum::Set< Key, Alloc >::Set ( const Set< Key, Alloc > & aHT )

Copy constructor.

Parameters

aHT	The gum::Set to copy.

Definition at line 346 of file set_tpl.h.

                                                           :
       inside__(s.inside__) {
     GUM_CONS_CPY(Set);
   }

◆ Set() [4/7]

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

template<typename OtherAlloc >

gum::Set< Key, Alloc >::Set ( const Set< Key, OtherAlloc > & aHT )

Generalized copy constructor.

Parameters

aHT	The gum::Set to copy.

Template Parameters

OtherAlloc The other gum::Set allocator.

◆ Set() [5/7]

template<typename Key, typename Alloc>

INLINE gum::Set< Key, Alloc >::Set ( Set< Key, Alloc > && aHT )

Move constructor.

Parameters

aHT	The gum::Set to move.

Definition at line 361 of file set_tpl.h.

                                                      :
       inside__(std::move(s.inside__)) {
     GUM_CONS_MOV(Set);
   }

◆ ~Set()

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

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

Class destructor.

◆ Set() [6/7]

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

gum::Set< Key, Alloc >::Set ( const HashTable< Key, bool, Alloc > & h )

private

Convert a hash table into a set of keys.

◆ Set() [7/7]

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

template<typename OtherAlloc >

INLINE gum::Set< Key, Alloc >::Set ( const Set< Key, OtherAlloc > & s )

Definition at line 354 of file set_tpl.h.

                                                                :
       inside__(s.inside__) {
     GUM_CONS_CPY(Set);
   }

Member Function Documentation

◆ begin()

template<typename Key , typename Alloc >

INLINE Set< Key, Alloc >::iterator gum::Set< Key, Alloc >::begin ( ) const

The usual unsafe begin iterator to parse the set.

Returns: Returns the usual unsafe begin iterator to parse the set.

Definition at line 516 of file set_tpl.h.

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

◆ beginSafe()

template<typename Key , typename Alloc >

INLINE Set< Key, Alloc >::iterator_safe gum::Set< Key, Alloc >::beginSafe ( ) const

The usual safe begin iterator to parse the set.

Returns: Returns The usual safe begin iterator to parse the set.

Definition at line 487 of file set_tpl.h.

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

◆ capacity()

template<typename Key , typename Alloc >

INLINE Size gum::Set< Key, Alloc >::capacity ( ) const

Returns the capacity of the underlying hash table containing the set.

The method runs in constant time.

Returns: Returns the capacity of the underlying hash table containing the set.

Definition at line 545 of file set_tpl.h.

                                                 {
     return inside__.capacity();
   }

◆ cbegin()

template<typename Key , typename Alloc >

INLINE Set< Key, Alloc >::const_iterator gum::Set< Key, Alloc >::cbegin ( ) const

The usual unsafe begin iterator to parse the set.

Returns: Returns the usual unsafe begin iterator to parse the set.

Definition at line 523 of file set_tpl.h.

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

◆ cbeginSafe()

template<typename Key , typename Alloc >

INLINE Set< Key, Alloc >::const_iterator_safe gum::Set< Key, Alloc >::cbeginSafe ( ) const

The usual safe begin iterator to parse the set.

Returns: Returns the usual safe begin iterator to parse the set.

Definition at line 494 of file set_tpl.h.

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

◆ cend()

template<typename Key , typename Alloc >

INLINE const Set< Key, Alloc >::const_iterator & gum::Set< Key, Alloc >::cend ( ) const

noexcept

The usual unsafe end iterator to parse the set.

Returns: Returns the usual unsafe end iterator to parse the set.

Definition at line 538 of file set_tpl.h.

                                             {
     return *(reinterpret_cast< const SetIterator< Key >* >(
        SetIteratorStaticEnd::SetIterEnd__));
   }

◆ cendSafe()

template<typename Key , typename Alloc >

INLINE const Set< Key, Alloc >::const_iterator_safe & gum::Set< Key, Alloc >::cendSafe ( ) const

noexcept

The usual safe end iterator to parse the set.

Returns: Returns the usual safe end iterator to parse the set.

Definition at line 509 of file set_tpl.h.

                                                 {
     return *(reinterpret_cast< const SetIteratorSafe< Key >* >(
        SetIteratorStaticEnd::SetIterEndSafe__));
   }

◆ clear()

template<typename Key , typename Alloc >

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

Removes all the elements, if any, from the set.

Definition at line 374 of file set_tpl.h.

                                        {
     // first we remove all the elements from the hashtable actually containing
     // the elements of the set. Note that, doing so, all the hashtable iterators
     // will be updated as well. In turn, this will imply that, whenever an
     // operation will be performed on a SetIteratorSafe, this will raise an
     // exception.
     inside__.clear();
 
     // Note that actually there is no need to update the end iterator as this
     // one
     // is not affected by changes within hashtables (adding/deleting elements).
     // Hence, for speedup, we do not update the end iterator
   }

◆ constEnd4Statics()

template<typename Key , typename Alloc >

INLINE const SetIterator< Key > & gum::Set< Key, Alloc >::constEnd4Statics ( )

static

Returns the end iterator for other classes' statics (read the detailed description of this method).

To reduce the Sets memory consumption (which are heavily used in aGrUM) while allowing fast for(iter=begin(); iter!=end();++iter) loops, end iterators are created just once as a static member of a non-template Set. While this scheme is efficient and it works quite effectively when manipulating sets, it has a drawback: other classes with static members using the Set's 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). OK, so what is the problem? Consider a class, say X, containing a Set 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 Set::end iterator. If the compiler decides to initialize X::end before initializing Set::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 Set::end is initialized before X::end. Using method Set::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 Sets. Now, this induces a small overhead. So, we also provide a Set::end() method that returns the Set::end iterator without this small overhead, but assuming that function end4Statics has already been called once (which is always the case) when a Set has been created.

So, to summarize: when initializing static members, use constEnd4Statics() rather than cend(). In all the other cases, use simply the usual method cend().

Returns: Returns the end iterator for other classes' statics (read the detailed description of this method).

Definition at line 311 of file set_tpl.h.

                                                                        {
     return *(reinterpret_cast< const SetIterator< Key >* >(
        SetIteratorStaticEnd::constEnd4Statics()));
   }

◆ constEndSafe4Statics()

template<typename Key , typename Alloc >

INLINE const SetIteratorSafe< Key > & gum::Set< Key, Alloc >::constEndSafe4Statics ( )

static

Returns the end iterator for other classes' statics (read the detailed description of this method).

To reduce the Sets memory consumption (which are heavily used in aGrUM) while allowing fast for(iter=begin(); iter!=end();++iter) loops, end iterators are created just once as a static member of a non-template Set. While this scheme is efficient and it works quite effectively when manipulating sets, it has a drawback: other classes with static members using the Set's 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). OK, so what is the problem? Consider a class, say X, containing a Set 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 Set::end iterator. If the compiler decides to initialize X::end before initializing Set::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 Set::end is initialized before X::end. Using method Set::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 Sets. Now, this induces a small overhead. So, we also provide a Set::end() method that returns the Set::end iterator without this small overhead, but assuming that function end4Statics has already been called once (which is always the case) when a Set has been created.

So, to summarize: when initializing static members, use constEndSafe4Statics() rather than cendSafe(). In all the other cases, use simply the usual method cendSafe ().

Returns: Returns the end iterator for other classes' statics (read the detailed description of this method).

Definition at line 297 of file set_tpl.h.

                                                                                {
     return *(reinterpret_cast< const SetIteratorSafe< Key >* >(
        SetIteratorStaticEnd::constEndSafe4Statics()));
   }

◆ contains()

template<typename Key, typename Alloc >

INLINE bool gum::Set< Key, Alloc >::contains ( const Key & k ) const

Indicates whether a given elements belong to the set.

Returns: Returns true if a given elements belong to the set.

Definition at line 580 of file set_tpl.h.

                                                             {
     return inside__.exists(k);
   }

◆ emplace() [1/2]

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

template<typename... Args>

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

Emplace a new element in the set.

Emplace is a method that 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

Warning: if the set already contains the element, nothing is done. In particular, it is not added to the set and no exception is thrown.

◆ emplace() [2/2]

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

template<typename... Args>

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

Definition at line 669 of file set_tpl.h.

                                                        {
     insert(std::move(Key(std::forward< Args >(args)...)));
   }

◆ empty()

template<typename Key , typename Alloc >

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

noexcept

Indicates whether the set is the empty set.

Returns: Returns true if the set is empty.

Definition at line 726 of file set_tpl.h.

                                                       {
     return inside__.empty();
   }

◆ end()

template<typename Key , typename Alloc >

INLINE const Set< Key, Alloc >::iterator & gum::Set< Key, Alloc >::end ( ) const

noexcept

The usual unsafe end iterator to parse the set.

Returns: Returns the usual unsafe end iterator to parse the set.

Definition at line 530 of file set_tpl.h.

                                            {
     return *(reinterpret_cast< const SetIterator< Key >* >(
        SetIteratorStaticEnd::SetIterEnd__));
   }

◆ end4Statics()

template<typename Key , typename Alloc >

INLINE const SetIterator< Key > & gum::Set< Key, Alloc >::end4Statics ( )

static

Returns the end iterator for other classes' statics (read the detailed description of this method).

To reduce the Sets memory consumption (which are heavily used in aGrUM) while allowing fast for(iter=begin(); iter!=end();++iter) loops, end iterators are created just once as a static member of a non-template Set. While this scheme is efficient and it works quite effectively when manipulating sets, it has a drawback: other classes with static members using the Set's 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). OK, so what is the problem? Consider a class, say X, containing a Set 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 Set::end iterator. If the compiler decides to initialize X::end before initializing Set::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 Set::end is initialized before X::end. Using method Set::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 Sets. Now, this induces a small overhead. So, we also provide a Set::end() method that returns the Set::end iterator without this small overhead, but assuming that function end4Statics has already been called once (which is always the case) when a Set has been created.

So, to summarize: when initializing static members, use end4Statics() rather than end(). In all the other cases, use simply the usual method end().

Returns: Returns the end iterator for other classes' statics (read the detailed description of this method).

Definition at line 304 of file set_tpl.h.

                                                                   {
     return *(reinterpret_cast< const SetIterator< Key >* >(
        SetIteratorStaticEnd::end4Statics()));
   }

◆ endSafe()

template<typename Key , typename Alloc >

INLINE const Set< Key, Alloc >::iterator_safe & gum::Set< Key, Alloc >::endSafe ( ) const

noexcept

The usual safe end iterator to parse the set.

Returns: Returns the usual safe end iterator to parse the set.

Definition at line 501 of file set_tpl.h.

                                                {
     return *(reinterpret_cast< const SetIteratorSafe< Key >* >(
        SetIteratorStaticEnd::SetIterEndSafe__));
   }

◆ endSafe4Statics()

template<typename Key , typename Alloc >

INLINE const SetIteratorSafe< Key > & gum::Set< Key, Alloc >::endSafe4Statics ( )

static

Returns the end iterator for other classes' statics (read the detailed description of this method).

To reduce the Sets memory consumption (which are heavily used in aGrUM) while allowing fast for(iter=begin(); iter!=end();++iter) loops, end iterators are created just once as a static member of a non-template Set. While this scheme is efficient and it works quite effectively when manipulating sets, it has a drawback: other classes with static members using the Set's 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). OK, so what is the problem? Consider a class, say X, containing a Set 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 Set::end iterator. If the compiler decides to initialize X::end before initializing Set::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 Set::end is initialized before X::end. Using method Set::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 Sets. Now, this induces a small overhead. So, we also provide a Set::end() method that returns the Set::end iterator without this small overhead, but assuming that function end4Statics has already been called once (which is always the case) when a Set has been created.

So, to summarize: when initializing static members, use endSafe4Statics() rather than endSafe (). In all the other cases, use simply the usual method endSafe ().

Returns: Returns the end iterator for other classes' statics (read the detailed description of this method).

Definition at line 290 of file set_tpl.h.

                                                                           {
     return *(reinterpret_cast< const SetIteratorSafe< Key >* >(
        SetIteratorStaticEnd::endSafe4Statics()));
   }

◆ erase() [1/2]

template<typename Key, typename Alloc >

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

Erases an element from the set.

Parameters

k	The element to remove.

Warning: if the set does not contain the element, nothing is done. In particular, no exception is thrown.

Definition at line 675 of file set_tpl.h.

                                                    {
     // erase the element (if it exists)
     inside__.erase(k);
 
     // Note that actually there is no need to update the end iterator as this
     // one
     // is not affected by changes within hashtables (adding/deleting elements).
     // Hence, for speedup, we do not update the end iterator
   }

◆ erase() [2/2]

template<typename Key, typename Alloc >

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

Erases an element from the set.

Parameters

k	The iterator pointing to the element to remove.

Warning: if the set does not contain the element, nothing is done. In particular, no exception is thrown.

Definition at line 687 of file set_tpl.h.

                                                                          {
     // erase the element
     inside__.erase(iter.ht_iter__);
 
     // Note that actually there is no need to update the end iterator as this
     // one
     // is not affected by changes within hashtables (adding/deleting elements).
     // Hence, for speedup, we do not update the end iterator
   }

◆ exists()

template<typename Key, typename Alloc >

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

Indicates whether a given elements belong to the set.

Returns: Returns true if a given elements belong to the set.

Definition at line 626 of file set_tpl.h.

                                                           {
     return inside__.exists(k);
   }

◆ hashMap() [1/2]

template<typename Key, typename Alloc >

template<typename NewKey , typename NewAlloc >

HashTable< Key, NewKey, NewAlloc > gum::Set< Key, Alloc >::hashMap	(	NewKey(*)(const Key &)	f,
		Size	capacity = `0`
	)		const

Creates a hashtable of NewKey from the set.

Warning: The order in the resulting hashtable may not be similar to that of the original set. Hence iterators on the former may not parse it in the same order as iterators on the latter.

Parameters

f	A function that maps Key into a NewKey
capacity	The size of the resulting hashtable. When equal to 0, a default size is computed that is a good trade-off between space consumption and efficiency of new elements insertions.

Definition at line 857 of file set_tpl.h.

                                                                         {
     // determine the proper size of the hashtable
     // by default, the size of the table is set so that the table does not take
     // too much space while allowing to add a few elements without resizing
     if (size == 0) size = std::max(Size(2), inside__.size() / 2);
 
     // create a new table
     HashTable< Key, NewKey, NewAlloc > table(size);
 
     // fill the new hash table
     for (HashTableConstIterator< Key, bool > iter = inside__.cbegin();
          iter != inside__.cend();
          ++iter) {
       table.insert(iter.key(), f(iter.key()));
     }
 
     return table;
   }

◆ hashMap() [2/2]

template<typename Key, typename Alloc >

template<typename NewKey , typename NewAlloc >

HashTable< Key, NewKey, NewAlloc > gum::Set< Key, Alloc >::hashMap	(	const NewKey &	val,
		Size	size = `0`
	)		const

Creates a hash table of NewKey from the set.

Warning: The order in the resulting hash table may not be similar to that of the original set. Hence iterators on the former may not parse it in the same order as iterators on the latter.

Parameters

val	The value taken by all the elements of the resulting hashtable.
size	The size of the resulting hash table. When equal to 0, a default size is computed that is a good trade-off between space consumption and efficiency of new elements insertions.

Definition at line 879 of file set_tpl.h.

                                                                                  {
     // determine the proper size of the hashtable
     // by default, the size of the table is set so that the table does not take
     // too much space while allowing to add a few elements without resizing
     if (size == 0) size = std::max(Size(2), inside__.size() / 2);
 
     // create a new table
     HashTable< Key, NewKey, NewAlloc > table(size);
 
     // fill the new hash table
     for (HashTableConstIterator< Key, bool > iter = inside__.cbegin();
          iter != inside__.cend();
          ++iter) {
       table.insert(iter.key(), val);
     }
 
     return table;
   }

◆ insert() [1/2]

template<typename Key, typename Alloc >

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

Inserts a new element into the set.

Parameters

k	The new element to insert.

Warning: if the set already contains the element, nothing is done. In particular, it is not added to the set and no exception is thrown.

Definition at line 632 of file set_tpl.h.

                                                     {
     // WARNING: we shall always test whether k already belongs to the set before
     // trying to insert it because we set inside__'s key uniqueness policy to
     // false
     if (!contains(k)) {
       // insert the element
       inside__.insert(k, true);
 
       // Note that actually there is no need to update the end iterator as this
       // one
       // is not affected by changes within hashtables (adding/deleting
       // elements).
       // Hence, for speedup, we do not update the end iterator
     }
   }

◆ insert() [2/2]

template<typename Key, typename Alloc >

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

Inserts a new element into the set.

Parameters

k	The new element to insert.

Warning: if the set already contains the element, nothing is done. In particular, it is not added to the set and no exception is thrown.

Definition at line 650 of file set_tpl.h.

                                                {
     // WARNING: we shall always test whether k already belongs to the set before
     // trying to insert it because we set inside__'s key uniqueness policy to
     // false
     if (!contains(k)) {
       // insert the element
       inside__.insert(std::move(k), true);
 
       // Note that actually there is no need to update the end iterator as this
       // one
       // is not affected by changes within hashtables (adding/deleting
       // elements).
       // Hence, for speedup, we do not update the end iterator
     }
   }

◆ isProperSubsetOf() [1/2]

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

template<typename OtherAlloc >

bool gum::Set< Key, Alloc >::isProperSubsetOf ( const Set< Key, OtherAlloc > & s ) const

Returns: Returns true if *this is a proper subset of s

◆ isProperSubsetOf() [2/2]

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

template<typename OtherAlloc >

INLINE bool gum::Set< Key, Alloc >::isProperSubsetOf ( const Set< Key, OtherAlloc > & s ) const

Definition at line 588 of file set_tpl.h.

                                                                               {
     if (this->size() >= s.size()) { return false; }
 
     for (const auto& elt: *this) {
       if (!s.contains(elt)) { return false; }
     }
     return true;
   }

◆ isProperSupersetOf() [1/2]

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

template<typename OtherAlloc >

bool gum::Set< Key, Alloc >::isProperSupersetOf ( const Set< Key, OtherAlloc > & s ) const

Returns: Returns true if *this is a proper superset of s

◆ isProperSupersetOf() [2/2]

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

template<typename OtherAlloc >

INLINE bool gum::Set< Key, Alloc >::isProperSupersetOf ( const Set< Key, OtherAlloc > & s ) const

Definition at line 600 of file set_tpl.h.

                                                                                 {
     return s.isProperSubsetOf(*this);
   }

◆ isSubsetOrEqual() [1/2]

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

template<typename OtherAlloc >

bool gum::Set< Key, Alloc >::isSubsetOrEqual ( const Set< Key, OtherAlloc > & s ) const

Returns: Returns true if *this is a subset of s (or equal to s)

◆ isSubsetOrEqual() [2/2]

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

template<typename OtherAlloc >

INLINE bool gum::Set< Key, Alloc >::isSubsetOrEqual ( const Set< Key, OtherAlloc > & s ) const

Definition at line 608 of file set_tpl.h.

                                                                              {
     if (this->size() > s.size()) { return false; }
 
     for (const auto& elt: *this) {
       if (!s.contains(elt)) { return false; }
     }
     return true;
   }

◆ isSupersetOrEqual() [1/2]

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

template<typename OtherAlloc >

bool gum::Set< Key, Alloc >::isSupersetOrEqual ( const Set< Key, OtherAlloc > & s ) const

Returns: Returns true if *this is a superset of s (or equal to s)

◆ isSupersetOrEqual() [2/2]

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

template<typename OtherAlloc >

INLINE bool gum::Set< Key, Alloc >::isSupersetOrEqual ( const Set< Key, OtherAlloc > & s ) const

Definition at line 620 of file set_tpl.h.

                                                                                {
     return s.isSubsetOrEqual(*this);
   }

◆ listMap()

template<typename Key, typename Alloc >

template<typename NewKey , typename NewAlloc >

List< NewKey, NewAlloc > gum::Set< Key, Alloc >::listMap ( NewKey(*)(const Key &) f ) const

A method to create a List of NewKey from the set.

Warning: The order of the NewKey elements in the resulting list is arbitrary.

Parameters

f	A function that maps a Key into a NewKey

Definition at line 903 of file set_tpl.h.

                                                              {
     // create a new list
     List< NewKey, NewAlloc > list;
 
     // fill the new list
     for (HashTableConstIterator< Key, bool > iter = inside__.cbegin();
          iter != inside__.cend();
          ++iter) {
       list.pushBack(f(iter.key()));
     }
 
     return list;
   }

◆ operator!=() [1/2]

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

template<typename OtherAlloc >

bool gum::Set< Key, Alloc >::operator!= ( const Set< Key, OtherAlloc > & s2 ) const

Mathematical inequality between two sets.

Parameters

s2	The gum::Set to test for inequality.

Template Parameters

OtherAlloc The other gum::Set allocator.

Returns: Returns true if both gum::Set are not equal.

◆ operator!=() [2/2]

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

template<typename OtherAlloc >

INLINE bool gum::Set< Key, Alloc >::operator!= ( const Set< Key, OtherAlloc > & s2 ) const

Definition at line 480 of file set_tpl.h.

                                                                          {
     return !(operator==(s2));
   }

◆ operator*()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

Set< Key, Alloc > gum::Set< Key, Alloc >::operator* ( const Set< Key, OtherAlloc > & s2 ) const

Intersection operator.

Template Parameters

OtherAlloc The other gum::Set allocator.

Parameters

s2	The gum::Set to intersect.

Returns: Returns a Set containing the elements belonging both to this and s2.

Definition at line 734 of file set_tpl.h.

                                                                         {
     Set< Key, Alloc >                         res;
     const HashTable< Key, bool, OtherAlloc >& h2  = s2.inside__;
     HashTable< Key, bool, Alloc >&            h_r = res.inside__;
 
     if (size() < h2.size()) {
       for (HashTableConstIterator< Key, bool > iter = inside__.cbegin();
            iter != inside__.cend();
            ++iter) {
         if (h2.exists(iter.key())) h_r.insert(iter.key(), true);
       }
     } else {
       for (HashTableConstIterator< Key, bool > iter = h2.cbegin();
            iter != h2.cend();
            ++iter) {
         if (inside__.exists(iter.key())) h_r.insert(iter.key(), true);
       }
     }
 
     return res;
   }

◆ operator*=()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

const Set< Key, Alloc > & gum::Set< Key, Alloc >::operator*= ( const Set< Key, OtherAlloc > & s2 )

Intersection update operator.

Template Parameters

OtherAlloc The other gum::Set allocator.

Parameters

s2	The gum::Set to intersect.

Returns: Returns this. Now this contains the elements belonging both to this and s2.

Definition at line 761 of file set_tpl.h.

                                                                    {
     if (&s2 != this) {
       const HashTable< Key, bool, OtherAlloc >& h2 = s2.inside__;
       for (auto iter = inside__.beginSafe(); iter != inside__.endSafe(); ++iter) {
         if (!h2.exists(iter.key())) inside__.erase(iter);
       }
     }
 
     return *this;
   }

◆ operator+()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

Set< Key, Alloc > gum::Set< Key, Alloc >::operator+ ( const Set< Key, OtherAlloc > & s2 ) const

Union operator.

Template Parameters

OtherAlloc The other gum::Set allocator.

Parameters

s2	The gum::Set to union.

Returns: Returns a new Set containing the union of the elements of this and s2.

Definition at line 792 of file set_tpl.h.

                                                                         {
     Set< Key, Alloc >                         res = *this;
     const HashTable< Key, bool, OtherAlloc >& h2  = s2.inside__;
     HashTable< Key, bool, Alloc >&            h_r = res.inside__;
 
     for (HashTableConstIterator< Key, bool > iter = h2.cbegin(); iter != h2.cend();
          ++iter) {
       if (!h_r.exists(iter.key())) h_r.insert(iter.key(), true);
     }
 
     return res;
   }

◆ operator+=()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

const Set< Key, Alloc > & gum::Set< Key, Alloc >::operator+= ( const Set< Key, OtherAlloc > & s2 )

Union update operator.

Template Parameters

OtherAlloc The other gum::Set allocator.

Parameters

s2	The gum::Set to update

Returns: Returns this. Now this contains the elements belonging both to this or to s2.

Definition at line 777 of file set_tpl.h.

                                                                    {
     if (&s2 != this) {
       for (auto pair: s2.inside__) {
         if (!inside__.exists(pair.first)) inside__.insert(pair.first, true);
       }
     }
 
     return *this;
   }

◆ operator-()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

Set< Key, Alloc > gum::Set< Key, Alloc >::operator- ( const Set< Key, OtherAlloc > & s2 ) const

Disjunction operator.

Template Parameters

OtherAlloc The other gum::Set allocator.

Parameters

s2	The gum::Set to disjunct.

Returns: Returns a Set whose elements belong to this but not to s2.

Warning: Unlike + and *, the - operator is not commutative!

Definition at line 810 of file set_tpl.h.

                                                                         {
     Set< Key, Alloc >                         res;
     const HashTable< Key, bool, OtherAlloc >& h2  = s2.inside__;
     HashTable< Key, bool, Alloc >&            h_r = res.inside__;
 
     for (HashTableConstIterator< Key, bool > iter = inside__.cbegin();
          iter != inside__.cend();
          ++iter)
       if (!h2.exists(iter.key())) h_r.insert(iter.key(), true);
 
     return res;
   }

◆ operator<<() [1/2]

template<typename Key, typename Alloc >

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

Adds a new element to the set (alias for insert).

Parameters

k	The new element to add.

Returns: Returns this gum::Set.

Definition at line 706 of file set_tpl.h.

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

◆ operator<<() [2/2]

template<typename Key, typename Alloc >

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

Adds a new element to the set (alias for insert).

Parameters

k	The new element to add.

Returns: Returns this gum::Set.

Definition at line 699 of file set_tpl.h.

                                                                       {
     insert(k);
     return *this;
   }

◆ operator=() [1/3]

template<typename Key, typename Alloc>

Set< Key, Alloc > & gum::Set< Key, Alloc >::operator= ( const Set< Key, Alloc > & from )

Copy operator.

Parameters

from	The gum::Set to copy.

Returns: Returns this gum::Set.

Definition at line 390 of file set_tpl.h.

                                                                             {
     // avoid self assignment
     if (&s != this) {
       // remove the old content of the set. Actually, we remove all the elements
       // from the underlying hashtable. Note that, doing so, all the hashtable
       // iterators will be updated as well. In turn, this will imply that,
       // whenever
       // an operation will be performed on a SetIteratorSafe, this will raise an
       // exception.
       clear();
 
       // prepare the set for its new data
       resize(s.capacity());
       setResizePolicy(s.resizePolicy());
 
       // copy the set
       inside__ = s.inside__;
 
       // Note that actually there is no need to update the end iterator as this
       // one
       // is not affected by changes within hashtables (adding/deleting
       // elements).
       // Hence, for speedup, we do not update the end iterator
     }
 
     return *this;
   }

◆ operator=() [2/3]

template<typename Key, typename Alloc >

template<typename OtherAlloc >

Set< Key, Alloc > & gum::Set< Key, Alloc >::operator= ( const Set< Key, OtherAlloc > & from )

Generalized copy operator.

Parameters

from	The gum::Set to copy.

Template Parameters

OtherAlloc The other gum::Set allocator.

Returns: Returns this gum::Set.

Definition at line 422 of file set_tpl.h.

                                                                  {
     // avoid self assignment
     if (this != reinterpret_cast< const Set< Key, Alloc >* >(&s)) {
       // remove the old content of the set. Actually, we remove all the elements
       // from the underlying hashtable. Note that, doing so, all the hashtable
       // iterators will be updated as well. In turn, this will imply that,
       // whenever
       // an operation will be performed on a SetIteratorSafe, this will raise an
       // exception.
       clear();
 
       // prepare the set for its new data
       resize(s.capacity());
       setResizePolicy(s.resizePolicy());
 
       // copy the set
       inside__ = s.inside__;
 
       // Note that actually there is no need to update the end iterator as this
       // one
       // is not affected by changes within hashtables (adding/deleting
       // elements).
       // Hence, for speedup, we do not update the end iterator
     }
 
     return *this;
   }

◆ operator=() [3/3]

template<typename Key, typename Alloc>

Set< Key, Alloc > & gum::Set< Key, Alloc >::operator= ( Set< Key, Alloc > && from )

Move operator.

Parameters

from	The gum::Set to move.

Returns: Returns this gum::Set.

Definition at line 452 of file set_tpl.h.

                                                                           {
     inside__ = std::move(from.inside__);
     return *this;
   }

◆ operator==()

template<typename Key, typename Alloc >

template<typename OtherAlloc >

bool gum::Set< Key, Alloc >::operator== ( const Set< Key, OtherAlloc > & s2 ) const

Mathematical equality between two sets.

Parameters

s2	The gum::Set to test for equality.

Template Parameters

OtherAlloc The other gum::Set allocator.

Returns: Returns true if both gum::Set are equal.

Definition at line 460 of file set_tpl.h.

                                                                            {
     const HashTable< Key, bool, OtherAlloc >& h2 = s2.inside__;
 
     // check whether both sets have the same number of elements
     if (size() != h2.size()) return false;
 
     // check the content of the sets
     for (HashTableConstIterator< Key, bool > iter = inside__.cbegin();
          iter != inside__.cend();
          ++iter) {
       if (!h2.exists(iter.key())) return false;
     }
 
     return true;
   }

◆ operator>>()

template<typename Key, typename Alloc >

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

Removes an element from the set (alias for erase).

Parameters

k	The element to remove.

Returns: Return this gum::Set.

Definition at line 713 of file set_tpl.h.

                                                                       {
     erase(k);
     return *this;
   }

◆ resize()

template<typename Key , typename Alloc >

INLINE void gum::Set< Key, Alloc >::resize ( Size new_capacity )

Changes the size of the underlying hash table containing the set.

See gum::HashTable::resize(Size) method resize for more details.

Parameters

new_capacity The underlying hash table new size.

Definition at line 551 of file set_tpl.h.

                                                      {
     inside__.resize(new_size);
 
     // Note that actually there is no need to update the end iterator as this
     // one
     // is not affected by changes within hashtables (adding/deleting elements).
     // Hence, for speedup, we do not update the end iterator
   }

◆ resizePolicy()

template<typename Key , typename Alloc >

INLINE bool gum::Set< Key, Alloc >::resizePolicy ( ) const

Returns the current resizing policy of the underlying hash table.

Returns: Returns the current resizing policy of the underlying hash table.

Definition at line 574 of file set_tpl.h.

                                                     {
     return inside__.resizePolicy();
   }

◆ setResizePolicy()

template<typename Key , typename Alloc >

INLINE void gum::Set< Key, Alloc >::setResizePolicy ( const bool new_policy )

Enables the user to change dynamically the resizing policy of the underlying hash table.

When new_policy is false, the set will not try to change its memory size, hence resulting in potentially slower accesses.

Parameters

new_policy If true the set updates dynamically its memory consumption to guarantee that its elements are fast to retrieve.

Definition at line 563 of file set_tpl.h.

                                                                       {
     inside__.setResizePolicy(new_policy);
 
     // Note that actually there is no need to update the end iterator as this
     // one
     // is not affected by changes within hashtables (adding/deleting elements).
     // Hence, for speedup, we do not update the end iterator
   }

◆ size()

template<typename Key , typename Alloc >

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

noexcept

Returns the number of elements in the set.

Returns: Returns the number of elements in the set.

Definition at line 720 of file set_tpl.h.

                                                      {
     return inside__.size();
   }

◆ toString()

template<typename Key , typename Alloc >

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

Prints the content of the set.

Returns: Returns the content of the set.

Definition at line 825 of file set_tpl.h.

                                                      {
     std::stringstream out;
     bool              first = true;
     out << "{";
 
     for (iterator iter = begin(); iter != end(); ++iter) {
       if (first) {
         out << *iter;
         first = false;
       } else {
         out << "," << *iter;
       }
     }
 
     out << "}";
 
     std::string res;
     out >> res;
     return res;
   }

Friends And Related Function Documentation

◆ Set

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

template<typename K , typename A >

friend class Set

friend

Friends to speed up access.

Definition at line 774 of file set.h.

◆ SetIterator< Key >

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

friend class SetIterator< Key >

friend

Friends to speed up access.

Definition at line 771 of file set.h.

◆ SetIteratorSafe< Key >

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

friend class SetIteratorSafe< Key >

friend

Friends to speed up access.

Definition at line 772 of file set.h.

Member Data Documentation

◆ inside__

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

HashTable< Key, bool, Alloc > gum::Set< Key, Alloc >::inside__

private

A set of X's is actually a hash table whose keys are the X's.

Definition at line 778 of file set.h.

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

agrum/tools/core/set.h
agrum/tools/core/set_tpl.h

Public Member Functions

Public Types

Friends

Iterators

Detailed Description

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

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_iterator_safe

◆ const_pointer

◆ const_reference

◆ difference_type

◆ iterator

◆ iterator_safe

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ Set() [1/7]

◆ Set() [2/7]

◆ Set() [3/7]

◆ Set() [4/7]

◆ Set() [5/7]

◆ ~Set()

◆ Set() [6/7]

◆ Set() [7/7]

Member Function Documentation

◆ begin()

◆ beginSafe()

◆ capacity()

◆ cbegin()

◆ cbeginSafe()

◆ cend()

◆ cendSafe()

◆ clear()

◆ constEnd4Statics()

◆ constEndSafe4Statics()

◆ contains()

◆ emplace() [1/2]

◆ emplace() [2/2]

◆ empty()

◆ end()

◆ end4Statics()

◆ endSafe()

◆ endSafe4Statics()

◆ erase() [1/2]

◆ erase() [2/2]

◆ exists()

◆ hashMap() [1/2]

◆ hashMap() [2/2]

◆ insert() [1/2]

◆ insert() [2/2]

◆ isProperSubsetOf() [1/2]

◆ isProperSubsetOf() [2/2]

◆ isProperSupersetOf() [1/2]

◆ isProperSupersetOf() [2/2]

◆ isSubsetOrEqual() [1/2]

◆ isSubsetOrEqual() [2/2]

◆ isSupersetOrEqual() [1/2]

◆ isSupersetOrEqual() [2/2]

◆ listMap()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator*()

◆ operator*=()

◆ operator+()

◆ operator+=()

◆ operator-()

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ operator==()

◆ operator>>()

◆ resize()

◆ resizePolicy()

◆ setResizePolicy()

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