# wxHashSet Class Reference
[Containers]

`#include </home/work/projects/wx/2.9/wx/interface/wx/hashset.h>`

## Detailed Description

This is a simple, type-safe, and reasonably efficient hash set class, whose interface is a subset of the interface of STL containers.

The interface is similar to std::tr1::hash_set or std::set classes but notice that, unlike std::set, the contents of a hash set is not sorted.

Example:

            class MyClass { ... };

            // same, with MyClass* keys (only uses pointer equality!)
            WX_DECLARE_HASH_SET( MyClass*, wxPointerHash, wxPointerEqual, MySet1 );
            // same, with int keys
            WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual, MySet2 );
            // declare a hash set with string keys
            WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual, MySet3 );

            MySet1 h1;
            MySet2 h1;
            MySet3 h3;

            // store and retrieve values
            h1.insert( new MyClass( 1 ) );

            h3.insert( "foo" );
            h3.insert( "bar" );
            h3.insert( "baz" );

            int size = h3.size(); // now is three
            bool has_foo = h3.find( "foo" ) != h3.end();

            h3.insert( "bar" ); // still has size three

            // iterate over all the elements in the class
            MySet3::iterator it;
            for( it = h3.begin(); it != h3.end(); ++it )
            {
                wxString key = *it;
                // do something useful with key
            }

## Declaring new hash set types

        WX_DECLARE_HASH_SET( KEY_T,      // type of the keys
                             HASH_T,     // hasher
                             KEY_EQ_T,   // key equality predicate
                             CLASSNAME); // name of the class

The HASH_T and KEY_EQ_T are the types used for the hashing function and key comparison. wxWidgets provides three predefined hashing functions: wxIntegerHash for integer types ( int, long, short, and their unsigned counterparts ), wxStringHash for strings ( wxString, wxChar*, char* ), and wxPointerHash for any kind of pointer. Similarly three equality predicates: wxIntegerEqual, wxStringEqual, wxPointerEqual are provided. Using this you could declare a hash set using int values like this:

            WX_DECLARE_HASH_SET( int,
                                wxIntegerHash,
                                wxIntegerEqual,
                                MySet );

            // using an user-defined class for keys
            class MyKey { ... };

            // hashing function
            class MyKeyHash
            {
            public:
                MyKeyHash() { }

                unsigned long operator()( const MyKey& k ) const
                    {
                        // compute the hash
                    }

                MyKeyHash& operator=(const MyKeyHash&) { return *this; }
            };

            // comparison operator
            class MyKeyEqual
            {
            public:
                MyKeyEqual() { }
                bool operator()( const MyKey& a, const MyKey& b ) const
                    {
                        // compare for equality
                    }

                MyKeyEqual& operator=(const MyKeyEqual&) { return *this; }
            };

            WX_DECLARE_HASH_SET( MyKey,      // type of the keys
                                MyKeyHash,  // hasher
                                MyKeyEqual, // key equality predicate
                                CLASSNAME); // name of the class

## Types

In the documentation below you should replace wxHashSet with the name you used in the class declaration.

- wxHashSet::key_type: Type of the hash keys
- wxHashSet::mapped_type: Type of hash keys
- wxHashSet::value_type: Type of hash keys
- wxHashSet::iterator: Used to enumerate all the elements in a hash set; it is similar to a value_type*
- wxHashSet::const_iterator: Used to enumerate all the elements in a constant hash set; it is similar to a const value_type*
- wxHashSet::size_type: Used for sizes
- wxHashSet::Insert_Result: The return value for insert()

## Iterators

An iterator is similar to a pointer, and so you can use the usual pointer operations: ++it ( and it++ ) to move to the next element, *it to access the element pointed to, *it to access the value of the element pointed to. Hash sets provide forward only iterators, this means that you can't use --it, it + 3, it1 - it2.

##

Library: wxBase
Category: Containers

## Public Member Functions

| wxHashSet (size_type size=10)
| The size parameter is just a hint, the table will resize automatically to preserve performance.
| wxHashSet (const wxHashSet &set)
| Copy constructor.
void | clear ()
| Removes all elements from the hash set.
size_type | count (const key_type &key) const
| Counts the number of elements with the given key present in the set.
bool | empty () const
| Returns true if the hash set does not contain any elements, false otherwise.
size_type | erase (const key_type &key)
| Erases the element with the given key, and returns the number of elements erased (either 0 or 1).
Insert_Result | insert (const value_type &v)
| Inserts the given value in the hash set.
size_type | size () const
| Returns the number of elements in the set.
const_iterator | begin () const
| Returns an iterator pointing at the first element of the hash set.
iterator | begin ()
| Returns an iterator pointing at the first element of the hash set.
const_iterator | end () const
| Returns an iterator pointing at the one-after-the-last element of the hash set.
iterator | end ()
| Returns an iterator pointing at the one-after-the-last element of the hash set.
void | erase (iterator it)
| Erases the element pointed to by the iterator.
void | erase (const_iterator it)
| Erases the element pointed to by the iterator.
iterator | find (const key_type &key) const
| If an element with the given key is present, the functions returns an iterator pointing at that element, otherwise an invalid iterator is returned; i.e.
const_iterator | find (const key_type &key) const
| If an element with the given key is present, the functions returns an iterator pointing at that element, otherwise an invalid iterator is returned; i.e.

List of all members.

## Constructor & Destructor Documentation

wxHashSet::wxHashSet | ( | size_type | size = `10` | ) |

The size parameter is just a hint, the table will resize automatically to preserve performance.

wxHashSet::wxHashSet | ( | const wxHashSet & | set | ) |

Copy constructor.

## Member Function Documentation

const_iterator wxHashSet::begin | ( |  | ) | const

Returns an iterator pointing at the first element of the hash set.

Please remember that hash sets do not guarantee ordering.

iterator wxHashSet::begin | ( |  | ) |

Returns an iterator pointing at the first element of the hash set.

Please remember that hash sets do not guarantee ordering.

void wxHashSet::clear | ( |  | ) |

Removes all elements from the hash set.

size_type wxHashSet::count | ( | const key_type & | key | ) | const

Counts the number of elements with the given key present in the set.

This function returns only 0 or 1.

bool wxHashSet::empty | ( |  | ) | const

Returns true if the hash set does not contain any elements, false otherwise.

const_iterator wxHashSet::end | ( |  | ) | const

Returns an iterator pointing at the one-after-the-last element of the hash set.

Please remember that hash sets do not guarantee ordering.

iterator wxHashSet::end | ( |  | ) |

Returns an iterator pointing at the one-after-the-last element of the hash set.

Please remember that hash sets do not guarantee ordering.

size_type wxHashSet::erase | ( | const key_type & | key | ) |

Erases the element with the given key, and returns the number of elements erased (either 0 or 1).

void wxHashSet::erase | ( | iterator | it | ) |

Erases the element pointed to by the iterator.

After the deletion the iterator is no longer valid and must not be used.

void wxHashSet::erase | ( | const_iterator | it | ) |

Erases the element pointed to by the iterator.

After the deletion the iterator is no longer valid and must not be used.

const_iterator wxHashSet::find | ( | const key_type & | key | ) | const

If an element with the given key is present, the functions returns an iterator pointing at that element, otherwise an invalid iterator is returned; i.e.

                hashset.find( non_existent_key ) == hashset.end()

iterator wxHashSet::find | ( | const key_type & | key | ) | const

If an element with the given key is present, the functions returns an iterator pointing at that element, otherwise an invalid iterator is returned; i.e.

                hashset.find( non_existent_key ) == hashset.end()

Insert_Result wxHashSet::insert | ( | const value_type & | v | ) |

Inserts the given value in the hash set.

The return value is equivalent to a

     std::pair<wxHashMap::iterator, bool>

The iterator points to the inserted element, the boolean value is true if v was actually inserted.

size_type wxHashSet::size | ( |  | ) | const

Returns the number of elements in the set.

|  | [ top ]