#include <OtherHashMaps.h>

Classes
class	item_iterator
struct	KeyItem
struct	ValueItem
Public Types
typedef Hasher	hasher
typedef SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >	map_type
typedef item_iterator< ValueItem >	value_iterator
typedef boost::mpl::if_ < typename boost::is_pointer < V >, V, V const & >::type	value_ref
Public Member Functions
void	clear (size_t newBucketSize=0)
void	dump ()
bool	empty () const
void	freeRows ()
void	insert (K const &key, value_ref value)
	SimpleAllocHashMultiMap (size_t buckets, size_t keyRowSize, size_t valueRowSize, size_t maxRows=50)
value_iterator	values (K const &key)
	~SimpleAllocHashMultiMap ()
Private Types
typedef Alloc::template rebind < KeyItem >::other	KeyItemAllocator
typedef Alloc::template rebind < KeyItem * >::other	KeyItemPtrAllocator
typedef Alloc::template rebind < ValueItem >::other	ValueItemAllocator
Private Member Functions
	BOOST_MPL_ASSERT ((boost::mpl::and_< boost::has_trivial_destructor< K >, boost::has_trivial_destructor< V > >))
KeyItem &	find_or_insert_ (K const &key)
ValueItem *	push_back_ (value_ref value, ValueItem *next)
KeyItem *	push_back_ (K const &key, KeyItem *next)
Private Attributes
size_t	bucketCapacity_
KeyItem **	buckets_
size_t	bucketSize_
std::list< KeyItem * >::iterator	currentKeyRow_
std::list< ValueItem * >::iterator	currentValueRow_
Equals	eq_
Hasher	hasher_
KeyItemAllocator	keyAlloc_
KeyItem *	keyEndMarker_
std::list< KeyItem * >	keyRows_
size_t	keyRowSize_
size_t	maxRows_
KeyItem *	nextKeyItem_
ValueItem *	nextValueItem_
KeyItemPtrAllocator	ptrAlloc_
ValueItemAllocator	valueAlloc_
ValueItem *	valueEndMarker_
std::list< ValueItem * >	valueRows_
size_t	valueRowSize_

Detailed Description

template<typename K, typename V, typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>
class cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >

Definition at line 31 of file OtherHashMaps.h.

Member Typedef Documentation

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef Hasher cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::hasher

Definition at line 35 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef Alloc::template rebind<KeyItem>::other cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItemAllocator [private]

Definition at line 111 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef Alloc::template rebind<KeyItem *>::other cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItemPtrAllocator [private]

Definition at line 112 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc> cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::map_type

Definition at line 36 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef item_iterator<ValueItem> cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::value_iterator

Definition at line 106 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef boost::mpl::if_<typename boost::is_pointer<V>, V, V const &>::type cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::value_ref

Definition at line 37 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

typedef Alloc::template rebind<ValueItem>::other cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::ValueItemAllocator [private]

Definition at line 113 of file OtherHashMaps.h.

Constructor & Destructor Documentation

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap	(	size_t	buckets,
		size_t	keyRowSize,
		size_t	valueRowSize,
		size_t	maxRows = `50`
	)

Definition at line 183 of file OtherHashMaps.h.

                                                                                                                                                :
    bucketSize_(buckets), bucketCapacity_(bucketSize_),
    keyRowSize_(keyRowSize),
    valueRowSize_(valueRowSize),
    maxRows_(maxRows)
{
    buckets_ = ptrAlloc_.allocate(bucketCapacity_);
    keyRows_.push_back(keyAlloc_.allocate(keyRowSize_));
    valueRows_.push_back(valueAlloc_.allocate(valueRowSize_));
    clear();
}

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::~SimpleAllocHashMultiMap ( )

Definition at line 195 of file OtherHashMaps.h.

References prof2calltree::last.

{
    for (typename std::list<KeyItem *>::iterator it = keyRows_.begin(), last = keyRows_.end(); it != last; ++it) {
        keyAlloc_.deallocate(*it, keyRowSize_);
    }
    for (typename std::list<ValueItem *>::iterator it = valueRows_.begin(), last = valueRows_.end(); it != last; ++it) {
        valueAlloc_.deallocate(*it, valueRowSize_);
    }
    ptrAlloc_.deallocate(buckets_, bucketCapacity_);
}

Member Function Documentation

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::BOOST_MPL_ASSERT ( (boost::mpl::and_< boost::has_trivial_destructor< K >, boost::has_trivial_destructor< V > >) ) [private]

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

void cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear ( size_t newBucketSize = 0 ) [inline]

Definition at line 43 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

                                           { 
            if (newBucketSize != 0) {
                if (newBucketSize > bucketCapacity_) {
                    ptrAlloc_.deallocate(buckets_, bucketCapacity_);
                    bucketCapacity_ = newBucketSize;
                    buckets_ = ptrAlloc_.allocate(bucketCapacity_);
                }
                bucketSize_ = newBucketSize;
            }
            memset(buckets_, 0, bucketSize_ * sizeof(KeyItem *));
            currentKeyRow_ = keyRows_.begin();
            nextKeyItem_ = keyRows_.front(); keyEndMarker_ = nextKeyItem_ + keyRowSize_;
            currentValueRow_ = valueRows_.begin();
            nextValueItem_ = valueRows_.front(); valueEndMarker_ = nextValueItem_ + valueRowSize_;
            if ((keyRows_.size() > maxRows_) || (valueRows_.size() > maxRows_)) freeRows();
        }

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

void cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump ( void ) [inline]

Definition at line 140 of file OtherHashMaps.h.

                    {
            std::cout << "Dumping HASH MULTIMAP" << std::endl;
            std::cout << "  Key items: " << (std::distance(keyRows_.begin(), currentKeyRow_) * keyRowSize_ + (nextKeyItem_ - *currentKeyRow_)) << std::endl;
            std::cout << "  Value items: " << (std::distance(valueRows_.begin(), currentValueRow_) * valueRowSize_ + (nextValueItem_ - *currentValueRow_)) << std::endl;
            size_t row = 0;
            std::cout << "  Buckets (size " << bucketSize_ << ", capacity " << bucketCapacity_ << ")";
            for (KeyItem **p = buckets_; p != buckets_ + bucketSize_; ++p, ++row) {
                std::cout << "      ["<<row<<"] " << *p << std::endl;
            }
            row = 0;
            std::cout << "  Key Items " << std::endl;
            for (typename std::list<KeyItem *>::iterator it = keyRows_.begin(), last = keyRows_.end(); it != last; ++it, ++row) {
                KeyItem *lastI = *it + keyRowSize_;
                std::cout << "   Key Row " << row <<  " (of size  " << keyRowSize_ << ")" << std::endl;
                for (KeyItem *p = *it; p != lastI; ++p) {
                    std::cout << "      @ " << p << " [" << p->key << ", @" << p->value <<"], next = " << p->next << std::endl;
                    if ((it == currentKeyRow_) && (p == nextKeyItem_ - 1)) {
                        std::cout << "      ^^^ this was the last valid item." << std::endl;
                        last = 0; break;
                    }
                }
                if (lastI == 0) break;
            }
            row = 0;
            std::cout << "  Value Items " << std::endl;
            for (typename std::list<ValueItem *>::iterator it = valueRows_.begin(), last = valueRows_.end(); it != last; ++it, ++row) {
                ValueItem *lastI = *it + valueRowSize_;
                std::cout << "   Value Row " << row <<  " (of size  " << valueRowSize_ << ")" << std::endl;
                for (ValueItem *p = *it; p != lastI; ++p) {
                    std::cout << "      @ " << p << " [" << p->value <<"], next = " << p->next << std::endl;
                    if ((it == currentValueRow_) && (p == nextValueItem_ - 1)) {
                        std::cout << "      ^^^ this was the last valid item." << std::endl;
                        last = 0; break;
                    }
                }
                if (lastI == 0) break;
            }
            std::cout << "  End of dump" << std::endl; 
            
        }

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

bool cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::empty ( void ) const [inline]

Definition at line 61 of file OtherHashMaps.h.

References cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::keyRows_, and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::nextKeyItem_.

{ return nextKeyItem_ == keyRows_.front(); }

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItem & cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::find_or_insert_ ( K const & key ) [private]

Definition at line 262 of file OtherHashMaps.h.

References cond::hash, cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItem::key, and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItem::next.

                                                                              {
    //std::cout << "Find or insert for key " << key << std::endl;
    size_t hash = hasher_(key);
    KeyItem * & buck = buckets_[hash % bucketSize_];
    KeyItem * curr = buck;
    while (curr) {
        if (eq_(curr->key, key)) {
            //std::cout << "  Key " << key << " was found." << std::endl;
            return *curr;
        } 
        curr = curr->next;
    } 
    buck = push_back_(key, buck);
    return *buck;
}

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

void cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::freeRows ( )

Definition at line 208 of file OtherHashMaps.h.

References prof2calltree::last.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear().

                                                           {
   if (keyRows_.size() > maxRows_) {
        //std::cerr << "Freeing key rows, current size is " << keyRows_.size() << std::endl;
        typename std::list<KeyItem *>::iterator it = keyRows_.begin(), last = keyRows_.end(); 
        for (std::advance(it, maxRows_); it != last; ++it) {
            keyAlloc_.deallocate(*it, keyRowSize_);
        }
        keyRows_.resize(maxRows_);
   } 
   if (valueRows_.size() > maxRows_) {
        //std::cerr << "Freeing value rows, current size is " << valueRows_.size() << std::endl;
        typename std::list<ValueItem *>::iterator it = valueRows_.begin(), last = valueRows_.end(); 
        for (std::advance(it, maxRows_); it != last; ++it) {
            valueAlloc_.deallocate(*it, valueRowSize_);
        }
        valueRows_.resize(maxRows_);
   } 
}

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

void cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::insert	(	K const &	key,
		value_ref	value
	)

Definition at line 279 of file OtherHashMaps.h.

References gen::k, and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItem::value.

                                                                                           {
    //std::cout << "Pushing back value " << value << " for key " << key << std::endl;
    KeyItem &k = find_or_insert_(key);
    //std::cout << "Key " << (k.value ? "exists" : " is new") << std::endl;
    k.value = push_back_(value, k.value);
}

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::ValueItem * cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::push_back_	(	value_ref	value,
		ValueItem *	next
	)		`[private]`

Definition at line 245 of file OtherHashMaps.h.

                                                                                             { 
    if (nextValueItem_ == valueEndMarker_) {
        ++currentValueRow_; 
        if (currentValueRow_ == valueRows_.end()) {
            valueRows_.push_back(valueAlloc_.allocate(valueRowSize_));
            currentValueRow_ = valueRows_.end(); --currentValueRow_; // end - 1 doesn't work!
        }
        nextValueItem_  = *currentValueRow_;
        valueEndMarker_ = nextValueItem_ + valueRowSize_; 
    }
    valueAlloc_.construct(nextValueItem_, ValueItem(next, value));
    nextValueItem_++;
    return (nextValueItem_-1);
}

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItem * cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::push_back_	(	K const &	key,
		KeyItem *	next
	)		`[private]`

Definition at line 229 of file OtherHashMaps.h.

                                                                                        { 
    if (nextKeyItem_ == keyEndMarker_) {
        ++currentKeyRow_; 
        if (currentKeyRow_ == keyRows_.end()) {
            keyRows_.push_back(keyAlloc_.allocate(keyRowSize_));
            currentKeyRow_ = keyRows_.end(); --currentKeyRow_; // end - 1 doesn't work!
        }
        nextKeyItem_  = *currentKeyRow_;
        keyEndMarker_ = nextKeyItem_ + keyRowSize_; 
    }
    keyAlloc_.construct(nextKeyItem_, KeyItem(next, key, 0));
    nextKeyItem_++;
    return (nextKeyItem_-1);
}

template<typename K , typename V , typename Hasher , typename Equals , typename Alloc >

SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::value_iterator cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::values ( K const & key )

Definition at line 288 of file OtherHashMaps.h.

References cond::hash, and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::KeyItem::next.

                                                                     {
    //std::cout << "Gettinv values for key " << key << std::endl;
    size_t hash = hasher_(key);
    for (KeyItem * curr = buckets_[hash % bucketSize_]; curr; curr = curr->next) {
        if (eq_(curr->key, key)) return value_iterator(curr->value);
    }
    return value_iterator();
}

Member Data Documentation

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

size_t cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::bucketCapacity_ [private]

Definition at line 116 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

KeyItem** cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::buckets_ [private]

Definition at line 117 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

size_t cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::bucketSize_ [private]

Definition at line 116 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

std::list<KeyItem *>::iterator cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::currentKeyRow_ [private]

Definition at line 121 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

std::list<ValueItem *>::iterator cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::currentValueRow_ [private]

Definition at line 126 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

Equals cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::eq_ [private]

Definition at line 131 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

Hasher cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::hasher_ [private]

Definition at line 130 of file OtherHashMaps.h.

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

KeyItemAllocator cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::keyAlloc_ [private]

Definition at line 132 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

KeyItem * cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::keyEndMarker_ [private]

Definition at line 122 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

std::list<KeyItem *> cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::keyRows_ [private]

Definition at line 120 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::empty(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

size_t cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::keyRowSize_ [private]

Definition at line 119 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

size_t cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::maxRows_ [private]

Definition at line 129 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

KeyItem* cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::nextKeyItem_ [private]

Definition at line 122 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::empty().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

ValueItem* cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::nextValueItem_ [private]

Definition at line 127 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

KeyItemPtrAllocator cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::ptrAlloc_ [private]

Definition at line 134 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

ValueItemAllocator cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::valueAlloc_ [private]

Definition at line 133 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

ValueItem * cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::valueEndMarker_ [private]

Definition at line 127 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

std::list<ValueItem *> cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::valueRows_ [private]

Definition at line 125 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

template<typename K , typename V , typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>

size_t cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::valueRowSize_ [private]

Definition at line 124 of file OtherHashMaps.h.

Referenced by cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::clear(), cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::dump(), and cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >::SimpleAllocHashMultiMap().

cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc > Class Template Reference

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

template<typename K, typename V, typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>> class cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename K, typename V, typename Hasher = boost::hash<K>, typename Equals = std::equal_to<K>, typename Alloc = std::allocator<V>>
class cmsutil::SimpleAllocHashMultiMap< K, V, Hasher, Equals, Alloc >