cliext::impl::hash< _Traits_t > Class Template Reference

Inheritance diagram for cliext::impl::hash< _Traits_t >:

Public Types
typedef hash< _Traits_t >	_Mytype_t
typedef _Traits_t	_Mybase_t
typedef _Traits_t::key_type	_Key_t
typedef _Traits_t::value_type	_Value_t
typedef _STLCLR IHash< _Key_t, _Value_t >	_Mycont_it
typedef System::Collections::Generic::IEnumerable< _Value_t >	_Myenum_it
typedef cli::array< _Value_t >	_Myarray_t
typedef list< _Value_t >	_Mylist_t
typedef list_node< _Value_t >	node_type
typedef cli::array< node_type^>	_Myvector_t
typedef _Mylist_t::iterator	iterator
typedef _Mylist_t::const_iterator	const_iterator
typedef _Mylist_t::reverse_iterator	reverse_iterator
typedef _Mylist_t::const_reverse_iterator	const_reverse_iterator
typedef _Traits_t::key_type	key_type
typedef _Traits_t::value_type	value_type
typedef _Traits_t::key_compare	key_compare
typedef _Traits_t::value_compare	value_compare
typedef _Traits_t::hasher	hasher
typedef int	size_type
typedef int	difference_type
typedef value_type	reference
typedef value_type	const_reference
typedef _Mycont_it	generic_container
typedef value_type	generic_value
typedef _STLCLR Generic::ContainerBidirectionalIterator< _Value_t >	generic_iterator
typedef _Mylist_t::generic_reverse_iterator	generic_reverse_iterator
typedef _STLCLR GenericPair< iterator, bool >	pair_iter_bool
typedef _STLCLR GenericPair< iterator, iterator >	pair_iter_iter
typedef _STLCLR GenericPair< node_type^, bool >	_Pairnb
typedef _STLCLR GenericPair< node_type^, node_type^>	_Pairnn
typedef _STLCLR GenericPair< generic_iterator^, bool >	generic_pair_iter_bool
typedef _STLCLR GenericPair< generic_iterator^, generic_iterator^>	generic_pair_iter_iter

Public Member Functions
	hash ()
	hash (hash%_Right)
hash	operator= (hash%_Right)
	operator _Mycont_it^ ()
	hash (key_compare^_Pred)
	hash (key_compare^_Pred, hasher^_Hashfn)
	~hash ()
unsigned long	get_generation ()
node_type	get_node (iterator _Where)
node_type	hash_node (size_type _Idx)
void	set_hash_node (size_type _Idx, node_type^_Node)
node_type	front_node ()
node_type	back_node ()
node_type	head_node ()
_Myarray_t	to_array ()
key_compare	key_comp () new
value_compare	value_comp () new
hasher	hash_delegate () new
iterator	make_iterator (node_type^_Node)
iterator	begin ()
iterator	end ()
reverse_iterator	rbegin ()
reverse_iterator	rend ()
size_type	size ()
bool	empty ()
int	bucket_count ()
float	load_factor ()
float	max_load_factor ()
void	max_load_factor (float _Newmax)
void	rehash (int _Buckets)
pair_iter_bool	insert (value_type _Val)
iterator	insert (iterator, value_type _Val)
template<typename _Iter_t >
void	insert (_Iter_t _First, _Iter_t _Last)
void	insert (_STLCLR Generic::IInputIterator< _Value_t >^_First, _STLCLR Generic::IInputIterator< _Value_t >^_Last)
void	insert (_Myenum_it^_Right)
void	insert (System::Collections::IEnumerable^_Right)
_Pairnb	insert_node (value_type _Val, list_node< value_type >^_Newnode)
iterator	erase (iterator _Where)
iterator	erase (iterator _First, iterator _Last)
size_type	erase (key_type _Keyval)
node_type	erase_node (node_type^_Where)
void	clear ()
void	swap (_Mytype_t%_Right)
iterator	find (key_type _Keyval)
size_type	count (key_type _Keyval)
iterator	lower_bound (key_type _Keyval)
node_type	lower_bound_node (key_type _Keyval)
iterator	upper_bound (key_type _Keyval)
node_type	upper_bound_node (key_type _Keyval)
pair_iter_iter	equal_range (key_type _Keyval)
_Pairnn	equal_range_node (key_type _Keyval)
void	dumptab ()
	for (;_Idx< _Oldsize;++_Idx) _Newvector[_Idx]
	for (;_Idx< _Newvector->Length;++_Idx) _Newvector[_Idx]
void	_Grow (int _Buckets)
size_type	_Hashval (key_type%_Keyval)
void	_Init (int _Buckets)
void	_Reinsert ()
void	_Rebuild_table (int _Buckets)
int	_True_buckets (int _Buckets)
virtual System::Object	Clone ()

Public Attributes
_STLCLR_FIELD_ACCESS	__pad0__: void _Resize(size_type _Newsize
_STLCLR_FIELD_ACCESS node_type	_Pad
size_type	_Oldsize = _Myvector == nullptr ? 0 : _Myvector->Length
_Myvector_t	_Newvector = gcnew _Myvector_t(_Newsize)
	_Myvector = _Newvector
_Mylist_t	_Mylist
_Myvector_t	_Myvector
unsigned long	_Mygen
int	_Mask
int	_Maxidx
float	_Max_load_factor

Static Public Attributes
static const int	_Maxsize = MAX_CONTAINER_SIZE
static const int	_Default_load = 4
static const int	_Default_buckets = 16

Private Attributes
property size_type	Count
property bool	IsSynchronized
property System::Object	SyncRoot

Member Typedef Documentation

template<typename _Traits_t>

typedef _Traits_t::key_type cliext::impl::hash< _Traits_t >::_Key_t

template<typename _Traits_t>

typedef cli::array<_Value_t> cliext::impl::hash< _Traits_t >::_Myarray_t

template<typename _Traits_t>

typedef _Traits_t cliext::impl::hash< _Traits_t >::_Mybase_t

template<typename _Traits_t>

typedef _STLCLR IHash<_Key_t, _Value_t> cliext::impl::hash< _Traits_t >::_Mycont_it

template<typename _Traits_t>

typedef System::Collections::Generic::IEnumerable<_Value_t> cliext::impl::hash< _Traits_t >::_Myenum_it

template<typename _Traits_t>

typedef list<_Value_t> cliext::impl::hash< _Traits_t >::_Mylist_t

template<typename _Traits_t>

typedef hash<_Traits_t> cliext::impl::hash< _Traits_t >::_Mytype_t

template<typename _Traits_t>

typedef cli::array<node_type^> cliext::impl::hash< _Traits_t >::_Myvector_t

template<typename _Traits_t>

typedef _STLCLR GenericPair<node_type^, bool> cliext::impl::hash< _Traits_t >::_Pairnb

template<typename _Traits_t>

typedef _STLCLR GenericPair<node_type^, node_type^> cliext::impl::hash< _Traits_t >::_Pairnn

template<typename _Traits_t>

typedef _Traits_t::value_type cliext::impl::hash< _Traits_t >::_Value_t

template<typename _Traits_t>

typedef _Mylist_t::const_iterator cliext::impl::hash< _Traits_t >::const_iterator

template<typename _Traits_t>

typedef value_type cliext::impl::hash< _Traits_t >::const_reference

template<typename _Traits_t>

typedef _Mylist_t::const_reverse_iterator cliext::impl::hash< _Traits_t >::const_reverse_iterator

template<typename _Traits_t>

typedef int cliext::impl::hash< _Traits_t >::difference_type

template<typename _Traits_t>

typedef _Mycont_it cliext::impl::hash< _Traits_t >::generic_container

template<typename _Traits_t>

typedef _STLCLR Generic::ContainerBidirectionalIterator<_Value_t> cliext::impl::hash< _Traits_t >::generic_iterator

template<typename _Traits_t>

typedef _STLCLR GenericPair<generic_iterator^, bool> cliext::impl::hash< _Traits_t >::generic_pair_iter_bool

template<typename _Traits_t>

typedef _STLCLR GenericPair<generic_iterator^, generic_iterator^> cliext::impl::hash< _Traits_t >::generic_pair_iter_iter

template<typename _Traits_t>

typedef _Mylist_t::generic_reverse_iterator cliext::impl::hash< _Traits_t >::generic_reverse_iterator

template<typename _Traits_t>

typedef value_type cliext::impl::hash< _Traits_t >::generic_value

template<typename _Traits_t>

typedef _Traits_t::hasher cliext::impl::hash< _Traits_t >::hasher

template<typename _Traits_t>

typedef _Mylist_t::iterator cliext::impl::hash< _Traits_t >::iterator

template<typename _Traits_t>

typedef _Traits_t::key_compare cliext::impl::hash< _Traits_t >::key_compare

template<typename _Traits_t>

typedef _Traits_t::key_type cliext::impl::hash< _Traits_t >::key_type

template<typename _Traits_t>

typedef list_node<_Value_t> cliext::impl::hash< _Traits_t >::node_type

template<typename _Traits_t>

typedef _STLCLR GenericPair<iterator, bool> cliext::impl::hash< _Traits_t >::pair_iter_bool

template<typename _Traits_t>

typedef _STLCLR GenericPair<iterator, iterator> cliext::impl::hash< _Traits_t >::pair_iter_iter

template<typename _Traits_t>

typedef value_type cliext::impl::hash< _Traits_t >::reference

template<typename _Traits_t>

typedef _Mylist_t::reverse_iterator cliext::impl::hash< _Traits_t >::reverse_iterator

template<typename _Traits_t>

typedef int cliext::impl::hash< _Traits_t >::size_type

template<typename _Traits_t>

typedef _Traits_t::value_compare cliext::impl::hash< _Traits_t >::value_compare

template<typename _Traits_t>

typedef _Traits_t::value_type cliext::impl::hash< _Traits_t >::value_type

Constructor & Destructor Documentation

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::hash ( )

inline

        {   // construct empty hash from default
        _Init(0);
        }

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::hash ( hash< _Traits_t >%  _Right )

inline

        :   _Mybase_t(_Right.comp, _Right.hash_fun)
        {   // construct by copying _Right
        _Init(_Right.bucket_count());
        _Mylist->insert_node(_Mylist->head_node(),
            _Right._Mylist->front_node(), _Right._Mylist->head_node());
        _Reinsert();
        }

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::hash ( key_compare^  _Pred )

inlineexplicit

        :   _Mybase_t(_Pred)
        {   // construct empty hash from compare
        _Init(0);
        }

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::hash ( key_compare^  _Pred, hasher^  _Hashfn  )

inline

        :   _Mybase_t(_Pred, _Hashfn)
        {   // construct empty hash from compare and hash
        _Init(0);
        }

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::~hash ( )

inline

        {   // destroy the object
        clear();
        _Mylist = nullptr;
        _Myvector = nullptr;
        ++_Mygen;
        }

Member Function Documentation

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::_Grow ( int  _Buckets )

inline

        {   // incrementally grow table
        for (; bucket_count() < _Buckets; )
            {   // too dense, need to grow hash table
            node_type^ _Node;

            if (_Myvector->Length - 1 <= _Maxidx)
                {   // table full, double its size
                _Mask = ((_Myvector->Length - 1) << 1) - 1;
                _Resize(_Mask + 2, head_node());
                }
            else if (_Mask < _Maxidx)
                _Mask = (_Mask << 1) + 1;

            size_type _Bucket = _Maxidx - (_Mask >> 1) - 1;

            for (_Node = hash_node(_Bucket);
                _Node != hash_node(_Bucket + 1); )
                {   // split old bucket
                size_type _Newbucket =
                    this->hash_fun(this->get_key(_Node->_Myval)) & _Mask;

                if (_Newbucket == _Bucket)
                    _Node = _Node->next_node(); // leave element in old bucket
                else
                    {   // move element to new bucket
                    size_type _Idx;
                    node_type^ _Next = _Node->next_node();

                    if (_Next != head_node())
                        {   // not at end, move it
                        for (_Idx = _Bucket; _Node == hash_node(_Idx); )
                            {   // update end iterators if moving first
                            set_hash_node(_Idx, _Next);
                            if (--_Idx < 0)
                                break;
                            }
                        _Mylist->splice_node(_Mylist->head_node(), _Mylist,
                            (list_node<value_type>^)_Node,
                            (list_node<value_type>^)_Next);
                        _Node = back_node();
                        _Myvector[_Maxidx + 1] = head_node();
                        }

                    for (_Idx = _Maxidx; _Bucket < _Idx; --_Idx)
                        {   // update end iterators if new bucket filled
                        if (hash_node(_Idx) != head_node())
                            break;
                        set_hash_node(_Idx, _Node);
                        }

                    if (_Next == head_node())
                        break;
                    else
                        _Node = _Next;
                    }
                }
            ++_Maxidx;  // open new bucket for hash lookup
            }
        }

template<typename _Traits_t>

size_type cliext::impl::hash< _Traits_t >::_Hashval ( key_type%  _Keyval )

inline

        {   // return hash value, masked and wrapped to current table size
        size_type _Num = this->hash_fun(_Keyval) & _Mask;

        if (_Maxidx <= _Num)
            _Num -= (_Mask >> 1) + 1;
        return (_Num);
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::_Init ( int  _Buckets )

inline

        {   // initialize for a minimum table size of _Buckets
        _Buckets = _True_buckets(_Buckets);
        _Mylist = gcnew _Mylist_t;
        _Myvector = nullptr;
        _Resize(_Buckets + 1, head_node());
        _Mygen = 0;

        _Mask = _Buckets - 1;
        _Maxidx = _Buckets;
        _Max_load_factor = _Default_load;
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::_Rebuild_table ( int  _Buckets )

inline

        {   // rebuild hash table
        _Myvector = nullptr;
        _Resize(_Buckets + 1, head_node());
        _Mask = _Buckets - 1;
        _Maxidx = _Buckets; // blow away old hash table

        _Reinsert();    // insert old list into table
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::_Reinsert ( )

inline

        {   // insert elements at beginning of list into table
        for (; front_node() != hash_node(0); )
            {   // hash another node
            list_node<value_type>^ _Node = _Mylist->front_node();

            insert_node(_Node->_Myval, _Node);
            }
        }

template<typename _Traits_t>

int cliext::impl::hash< _Traits_t >::_True_buckets ( int  _Buckets )

inline

        {   // canonicalize bucket count
        if (_Buckets < 0)
            throw gcnew System::ArgumentException();

        int _Newsize = _Default_buckets;

        for (; _Newsize < _Buckets && _Newsize < _Maxsize / 2; )
            _Newsize *= 2;  // double until big enough
        return (_Newsize);
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::back_node ( )

inline

        {   // return rightmost node in list
        return (_Mylist->back_node());
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::begin ( )

inline

        {   // return iterator for beginning of mutable sequence
        return (_Mylist->begin());
        }

template<typename _Traits_t>

int cliext::impl::hash< _Traits_t >::bucket_count ( )

inline

        {   // return number of buckets in table
        return (_Maxidx);
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::clear ( )

inline

        {   // erase all
        _Mylist->clear();
        _Rebuild_table(_Myvector->Length - 1);
        ++_Mygen;
        }

template<typename _Traits_t>

virtual System::Object cliext::impl::hash< _Traits_t >::Clone ( )

inlinevirtual

Reimplemented in cliext::hash_multimap< _Key1_t, _Mapped_t >, cliext::hash_map< _Key1_t, _Mapped_t >, cliext::hash_multiset< _Key1_t >, and cliext::hash_set< _Key1_t >.

        {   // clone the hash
        return (gcnew hash(*this));
        }

template<typename _Traits_t>

size_type cliext::impl::hash< _Traits_t >::count ( key_type  _Keyval )

inline

        {   // count all elements that match _Keyval
        node_type^ _First = lower_bound_node(_Keyval);
        node_type^ _Last = upper_bound_node(_Keyval);
        size_type _Num = 0;

        for (; _First != _Last; _First = _First->next_node())
            ++_Num;
        return (_Num);
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::dumptab ( )

inline

    {
    int i;
    int siz = _Myvector->Length;

    System::Console::WriteLine("\nmaxidx = {0}, mask = {1}", _Maxidx, _Mask);
    for (i = 0; i < siz; ++i)
        {
        node_type^ p;

        System::Console::Write("bucket {0}:", i);
        if (hash_node(i) != head_node())
        System::Console::Write("begins with {0}:",
            (char)hash_node(i)->_Myval->first);
        if (hash_node(i) == head_node())
            break;
        else if (i + 1 == siz)
            for (p = hash_node(i); p != head_node(); p = p->next_node())
                System::Console::Write(" {0}", (char)p->_Myval->first);
        else
            for (p = hash_node(i); p != hash_node(i + 1); p = p->next_node())
                System::Console::Write(" {0}", (char)p->_Myval->first);
        System::Console::WriteLine(" end");
        }
    System::Console::WriteLine("dump end");
    }

template<typename _Traits_t>

bool cliext::impl::hash< _Traits_t >::empty ( )

inline

        {   // test if sequence is empty
        return (size() == 0);
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::end ( )

inline

        {   // return iterator for end of mutable sequence
        return (_Mylist->end());
        }

template<typename _Traits_t>

pair_iter_iter cliext::impl::hash< _Traits_t >::equal_range ( key_type  _Keyval )

inline

        {   // find range equivalent to _Keyval
        _Pairnn _Ans = equal_range_node(_Keyval);
        return (pair_iter_iter(iterator(_Ans.first),
            iterator(_Ans.second)));
        }

template<typename _Traits_t>

_Pairnn cliext::impl::hash< _Traits_t >::equal_range_node ( key_type  _Keyval )

inline

        {   // find range equivalent to _Keyval
        return (_Pairnn(lower_bound_node(_Keyval),
            upper_bound_node(_Keyval)));
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::erase ( iterator  _Where )

inline

        {   // erase element at _Where
        return (make_iterator(erase_node(get_node(_Where))));
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::erase ( iterator  _First, iterator  _Last  )

inline

        {   // erase [_First, _Last)
        node_type^ _First_node = get_node(_First);
        node_type^ _Last_node = get_node(_Last);

        if (_First_node == front_node() && _Last_node == head_node())
            clear();    // erase all
        else
            for (; _First_node != _Last_node; )
                _First_node = erase_node(_First_node);
        return (_Last);
        }

template<typename _Traits_t>

size_type cliext::impl::hash< _Traits_t >::erase ( key_type  _Keyval )

inline

        {   // erase and count all that match _Keyval
        node_type^ _First = lower_bound_node(_Keyval);
        node_type^ _Last = upper_bound_node(_Keyval);
        size_type _Num = 0;

        for (; _First != _Last; ++_Num)
            _First = erase_node(_First);    // erase an element matching key
        return (_Num);
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::erase_node ( node_type^  _Where )

inline

        {   // erase node at _Where
        if (_Where->container() != _Mylist || _Where->is_head())
            throw gcnew System::InvalidOperationException();

        size_type _Bucket = _Hashval(this->get_key(_Where->_Myval));

        for (; _Where == hash_node(_Bucket); --_Bucket)
            {   // update end iterators if erasing first
            set_hash_node(_Bucket, hash_node(_Bucket)->next_node());
            if (_Bucket == 0)
                break;
            }

        ++_Mygen;
        return (_Mylist->erase_node((list_node<value_type>^)_Where));
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::find ( key_type  _Keyval )

inline

        {   // find an element that matches _Keyval, return iterator
        return (make_iterator(lower_bound_node(_Keyval)));
        }

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::for

(

)

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::for

(

;_Idx< _Newvector->Length;++

_Idx

)

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::front_node ( )

inline

        {   // return leftmost node in list
        return (_Mylist->front_node());
        }

template<typename _Traits_t>

unsigned long cliext::impl::hash< _Traits_t >::get_generation ( )

inline

        {   // get underlying container generation
        return (_Mygen);
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::get_node ( iterator  _Where )

inline

        {   // get node from valid iterator
        return (_Mylist->get_node(_Mylist_t::iterator(_Where)));
        }

template<typename _Traits_t>

hasher cliext::impl::hash< _Traits_t >::hash_delegate ( )

inlinenew

        {   // return object for hashing key
        return (_Mybase_t::hash_delegate());
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::hash_node ( size_type  _Idx )

inline

        {   // get node from hash table
        return (_Myvector[_Idx]);
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::head_node ( )

inline

        {   // get head node
        return (_Mylist->head_node());
        }

template<typename _Traits_t>

pair_iter_bool cliext::impl::hash< _Traits_t >::insert ( value_type  _Val )

inline

        {   // try to insert node with value _Val, return iterator, bool
        _Pairnb _Ans = insert_node(_Val, nullptr);

        return (pair_iter_bool(iterator(_Ans.first),
            _Ans.second));
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::insert ( iterator  , value_type  _Val  )

inline

        {   // try to insert node with value _Val at _Where, return iterator
        _Pairnb _Ans = insert_node(_Val, nullptr);

        return (make_iterator(_Ans.first));
        }

template<typename _Traits_t>

template<typename _Iter_t >

void cliext::impl::hash< _Traits_t >::insert ( _Iter_t  _First, _Iter_t  _Last  )

inline

        {   // insert [_First, _Last) one at a time
#pragma warning(push)
#pragma warning(disable: 4127)
        if (_Iter_container(_First) != _Mylist)
            for (; _First != _Last; ++_First)
                insert_node(*_First, nullptr);
        else if (_Multi)
            {   // worth assigning to self
            for (; _First != _Last; ++_First)
                _Mylist->insert_node(_Mylist->front_node(), 1, *_First);
            _Reinsert();
            }
#pragma warning(pop)
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::insert ( _STLCLR Generic::IInputIterator< _Value_t >^  _First, _STLCLR Generic::IInputIterator< _Value_t >^  _Last  )

inline

        {   // insert [_First, _Last) one at a time
#pragma warning(push)
#pragma warning(disable: 4127)
        if (_First->container() != _Mylist)
            for (; !_First->equal_to(_Last); _First->next())
                insert_node((value_type%)_First->get_cref(), nullptr);
        else if (_Multi)
            {   // worth assigning to self
            for (; !_First->equal_to(_Last); _First->next())
                _Mylist->insert_node(front_node(), 1,
                    (value_type%)_First->get_cref());
            _Reinsert();
            }
#pragma warning(pop)
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::insert ( _Myenum_it^  _Right )

inline

        {   // insert enumerable
        for each (value_type _Val in _Right)
            _Mylist->insert_node(_Mylist->front_node(), 1, _Val);
        _Reinsert();
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::insert ( System::Collections::IEnumerable^  _Right )

inline

        {   // insert enumerable
        for each (value_type _Val in _Right)
            _Mylist->insert_node(_Mylist->front_node(), 1, _Val);
        _Reinsert();
        }

template<typename _Traits_t>

_Pairnb cliext::impl::hash< _Traits_t >::insert_node ( value_type  _Val, list_node< value_type >^  _Newnode  )

inline

        {   // try to insert node with value _Val, return node pointer, bool
#pragma warning(push)
#pragma warning(disable: 4127)
        size_type _Bucket = _Hashval(this->get_key(_Val));
        node_type^ _Node = hash_node(_Bucket + 1);  // end node for bucket

        for (; _Node != hash_node(_Bucket); )
            if (!this->comp(this->get_key(_Val),
                this->get_key((_Node = _Node->prev_node())->_Myval)))
                ;   // still too high in bucket list
            else if (_Multi
                || !this->comp(this->get_key(_Node->_Myval),
                    this->get_key(_Val)))
                {   // found insertion point, back up to it
                _Node = _Node->next_node();
                break;
                }
            else
                {   // discard new node and return existing node
                if (_Newnode != nullptr)
                    _Mylist->erase_node(_Newnode);
                return (_Pairnb(_Node, false));
                }
        if (_Newnode != nullptr)
            _Mylist->splice_node((list_node<value_type>^)_Node, _Mylist,
                _Newnode, _Newnode->_Next); // place existing node
        else
            {   // insert value to make new node
            _Mylist->insert_node((list_node<value_type>^)_Node, 1, _Val);
            _Newnode = (list_node<value_type>^)_Node->prev_node();
            }

        for (; _Node == hash_node(_Bucket); --_Bucket)
            {   // update end iterators if new first bucket element
            set_hash_node(_Bucket, _Newnode);
            if (_Bucket == 0)
                break;
            }

        if (max_load_factor() < load_factor())
            _Grow(bucket_count() + 1);
        ++_Mygen;
        return (_Pairnb(_Newnode, true));   // return added node
#pragma warning(pop)
        }

template<typename _Traits_t>

key_compare cliext::impl::hash< _Traits_t >::key_comp ( )

inlinenew

        {   // return object for comparing keys
        return (_Mybase_t::key_comp());
        }

template<typename _Traits_t>

float cliext::impl::hash< _Traits_t >::load_factor ( )

inline

        {   // return average number of elements per bucket
        return ((float)size() / (float)bucket_count());
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::lower_bound ( key_type  _Keyval )

inline

        {   // find leftmost node not less than _Keyval
        return (make_iterator(lower_bound_node(_Keyval)));
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::lower_bound_node ( key_type  _Keyval )

inline

        {   // find leftmost node not less than _Keyval
        size_type _Bucket = _Hashval(_Keyval);
        node_type^ _Where = hash_node(_Bucket);

        for (; _Where != hash_node(_Bucket + 1);
            _Where = _Where->next_node())
            if (this->comp(this->get_key(_Where->_Myval), _Keyval))
                return (!this->comp(_Keyval,
                    this->get_key(_Where->_Myval)) ? head_node() : _Where);
        return (head_node());
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::make_iterator ( node_type^  _Node )

inline

        {   // return iterator for node
        return (_Mylist->make_iterator(_Node));
        }

template<typename _Traits_t>

float cliext::impl::hash< _Traits_t >::max_load_factor ( )

inline

        {   // return maximum number of elements per bucket
        return (_Max_load_factor);
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::max_load_factor ( float  _Newmax )

inline

        {   // set maximum load factor
        if (_Newmax != _Newmax  // might detect a NaN
            || _Newmax <= 0)
            throw gcnew System::ArgumentException();

        _Max_load_factor = _Newmax;
        }

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::operator _Mycont_it^ ( )

inline

        {   // convert to interface
        return (this);
        }

template<typename _Traits_t>

hash cliext::impl::hash< _Traits_t >::operator= ( hash< _Traits_t >%  _Right )

inline

        {   // assign
        if ((Object^)this != %_Right)
            {   // worth doing, do it
            clear();
            _Mylist->insert_node(_Mylist->head_node(),
                _Right._Mylist->front_node(), _Right._Mylist->head_node());
            _Reinsert();
            }
        return (*this);
        }

template<typename _Traits_t>

reverse_iterator cliext::impl::hash< _Traits_t >::rbegin ( )

inline

        {   // return reverse iterator for beginning of mutable sequence
        return (_Mylist->rbegin());
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::rehash ( int  _Buckets )

inline

        {   // try to grow table to at least _Buckets buckets
        _Buckets = _True_buckets(_Buckets);

        if ((float)size() / (float)_Buckets <= max_load_factor())
            _Rebuild_table(_Buckets);
        }

template<typename _Traits_t>

reverse_iterator cliext::impl::hash< _Traits_t >::rend ( )

inline

        {   // return reverse iterator for end of mutable sequence
        return (_Mylist->rend());
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::set_hash_node ( size_type  _Idx, node_type^  _Node  )

inline

        {   // set node from hash table
        _Myvector[_Idx] = _Node;
        }

template<typename _Traits_t>

size_type cliext::impl::hash< _Traits_t >::size ( )

inline

        {   // return length of sequence
        return (_Mylist->size());
        }

template<typename _Traits_t>

void cliext::impl::hash< _Traits_t >::swap ( _Mytype_t%  _Right )

inline

        {   // exchange contents with _Right
        if ((Object^)this != %_Right)
            {   // worth doing, swap
            _Mylist_t^ _Tlist = _Mylist;
            _Myvector_t^ _Tvector = _Myvector;
            int _Tmask = _Mask;
            int _Tmaxidx = _Maxidx;
            float _Tmax_load_factor = _Max_load_factor;

            _Mylist = _Right._Mylist;
            _Right._Mylist = _Tlist;

            _Myvector = _Right._Myvector;
            _Right._Myvector = _Tvector;

            _Mask = _Right._Mask;
            _Right._Mask = _Tmask;

            _Maxidx = _Right._Maxidx;
            _Right._Maxidx = _Tmaxidx;

            _Max_load_factor = _Right._Max_load_factor;
            _Right._Max_load_factor = _Tmax_load_factor;
            ++_Mygen;
            ++_Right._Mygen;
            }
        }

template<typename _Traits_t>

_Myarray_t cliext::impl::hash< _Traits_t >::to_array ( )

inline

        {   // convert to array
        return (_Mylist->to_array());
        }

template<typename _Traits_t>

iterator cliext::impl::hash< _Traits_t >::upper_bound ( key_type  _Keyval )

inline

        {   // find leftmost node greater than _Keyval
        return (make_iterator(upper_bound_node(_Keyval)));
        }

template<typename _Traits_t>

node_type cliext::impl::hash< _Traits_t >::upper_bound_node ( key_type  _Keyval )

inline

        {   // find leftmost node greater than _Keyval
        size_type _Bucket = _Hashval(_Keyval);
        node_type^ _Where = hash_node(_Bucket + 1);

        for (; _Where != hash_node(_Bucket); )
            {   // scan down to first that matches key, then back up one
            _Where = _Where->prev_node();
            if (this->comp(_Keyval, this->get_key(_Where->_Myval)))
                return (!this->comp(this->get_key(_Where->_Myval),
                    _Keyval) ? head_node() : _Where->next_node());
            }
        return (head_node());
        }

template<typename _Traits_t>

value_compare cliext::impl::hash< _Traits_t >::value_comp ( )

inlinenew

        {   // return object for comparing keys
        return (_Mybase_t::value_comp());
        }

Member Data Documentation

template<typename _Traits_t>

_STLCLR_FIELD_ACCESS cliext::impl::hash< _Traits_t >::__pad0__

template<typename _Traits_t>

const int cliext::impl::hash< _Traits_t >::_Default_buckets = 16

static

template<typename _Traits_t>

const int cliext::impl::hash< _Traits_t >::_Default_load = 4

static

template<typename _Traits_t>

int cliext::impl::hash< _Traits_t >::_Mask

template<typename _Traits_t>

float cliext::impl::hash< _Traits_t >::_Max_load_factor

template<typename _Traits_t>

int cliext::impl::hash< _Traits_t >::_Maxidx

template<typename _Traits_t>

const int cliext::impl::hash< _Traits_t >::_Maxsize = MAX_CONTAINER_SIZE

static

template<typename _Traits_t>

unsigned long cliext::impl::hash< _Traits_t >::_Mygen

template<typename _Traits_t>

_Mylist_t cliext::impl::hash< _Traits_t >::_Mylist

template<typename _Traits_t>

cliext::impl::hash< _Traits_t >::_Myvector = _Newvector

template<typename _Traits_t>

_Myvector_t cliext::impl::hash< _Traits_t >::_Myvector

template<typename _Traits_t>

_Myvector_t cliext::impl::hash< _Traits_t >::_Newvector = gcnew _Myvector_t(_Newsize)

template<typename _Traits_t>

size_type cliext::impl::hash< _Traits_t >::_Oldsize = _Myvector == nullptr ? 0 : _Myvector->Length

template<typename _Traits_t>

_STLCLR_FIELD_ACCESS node_type cliext::impl::hash< _Traits_t >::_Pad

Initial value:

{   
        size_type _Idx = 0

template<typename _Traits_t>

property size_type cliext::impl::hash< _Traits_t >::Count

private

Initial value:

{   
        virtual size_type get() sealed
            = System::Collections::ICollection::Count::get
            {   
            return (size());
            }
        }

template<typename _Traits_t>

property bool cliext::impl::hash< _Traits_t >::IsSynchronized

private

Initial value:

{   
        virtual bool get() sealed
            = System::Collections::ICollection::IsSynchronized::get
            {   
            return (false);
            }
        }

template<typename _Traits_t>

property System::Object cliext::impl::hash< _Traits_t >::SyncRoot

private

Initial value:

{   
        virtual System::Object^ get() sealed
            = System::Collections::ICollection::SyncRoot::get
            {   
            return (this);
            }
        }

---

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

• VS2013/inc/cliext/xhash