SkTMultiMap< T, Key, HashTraits > Class Template Reference

#include <SkTMultiMap.h>

Public Member Functions
	SkTMultiMap ()
	~SkTMultiMap ()
void	reset ()
void	insert (const Key &key, T *value)
void	remove (const Key &key, const T *value)
T *	find (const Key &key) const
template<class FindPredicate >
T *	find (const Key &key, const FindPredicate f)
template<class FindPredicate >
T *	findAndRemove (const Key &key, const FindPredicate f)
int	count () const

Detailed Description

template<typename T, typename Key, typename HashTraits = T>
class SkTMultiMap< T, Key, HashTraits >

A set that contains pointers to instances of T. Instances can be looked up with key Key. Multiple (possibly same) values can have the same key.

Definition at line 19 of file SkTMultiMap.h.

Constructor & Destructor Documentation

SkTMultiMap()

template<typename T , typename Key , typename HashTraits = T>

SkTMultiMap< T, Key, HashTraits >::SkTMultiMap ( )

inline

Definition at line 29 of file SkTMultiMap.h.

: fCount(0) {}

~SkTMultiMap()

template<typename T , typename Key , typename HashTraits = T>

SkTMultiMap< T, Key, HashTraits >::~SkTMultiMap ( )

inline

Definition at line 31 of file SkTMultiMap.h.

                   {
        this->reset();
    }

Member Function Documentation

count()

template<typename T , typename Key , typename HashTraits = T>

int SkTMultiMap< T, Key, HashTraits >::count ( ) const

inline

Definition at line 131 of file SkTMultiMap.h.

{ return fCount; }

find() [1/2]

template<typename T , typename Key , typename HashTraits = T>

T * SkTMultiMap< T, Key, HashTraits >::find ( const Key &  key ) const

inline

Definition at line 94 of file SkTMultiMap.h.

                                  {
        ValueList* list = fHash.find(key);
        if (list) {
            return list->fValue;
        }
        return nullptr;
    }

find() [2/2]

template<typename T , typename Key , typename HashTraits = T>

template<class FindPredicate >

T * SkTMultiMap< T, Key, HashTraits >::find ( const Key &  key, const FindPredicate  f  )

inline

Definition at line 103 of file SkTMultiMap.h.

                                                   {
        ValueList* list = fHash.find(key);
        while (list) {
            if (f(list->fValue)){
                return list->fValue;
            }
            list = list->fNext;
        }
        return nullptr;
    }

findAndRemove()

template<typename T , typename Key , typename HashTraits = T>

template<class FindPredicate >

T * SkTMultiMap< T, Key, HashTraits >::findAndRemove ( const Key &  key, const FindPredicate  f  )

inline

Definition at line 115 of file SkTMultiMap.h.

                                                            {
        ValueList* list = fHash.find(key);
 
        ValueList* prev = nullptr;
        while (list) {
            if (f(list->fValue)){
                T* value = list->fValue;
                this->internalRemove(prev, list, key);
                return value;
            }
            prev = list;
            list = list->fNext;
        }
        return nullptr;
    }

insert()

template<typename T , typename Key , typename HashTraits = T>

void SkTMultiMap< T, Key, HashTraits >::insert ( const Key &  key, T *  value  )

inline

Definition at line 48 of file SkTMultiMap.h.

                                          {
        ValueList* list = fHash.find(key);
        if (list) {
            // The new ValueList entry is inserted as the second element in the
            // linked list, and it will contain the value of the first element.
            ValueList* newEntry = new ValueList(list->fValue);
            newEntry->fNext = list->fNext;
            // The existing first ValueList entry is updated to contain the
            // inserted value.
            list->fNext = newEntry;
            list->fValue = value;
        } else {
            fHash.add(new ValueList(value));
        }
 
        ++fCount;
    }

remove()

template<typename T , typename Key , typename HashTraits = T>

void SkTMultiMap< T, Key, HashTraits >::remove ( const Key &  key, const T *  value  )

inline

Definition at line 66 of file SkTMultiMap.h.

                                                {
        ValueList* list = fHash.find(key);
        // Temporarily making this safe for remove entries not in the map because of
        // crbug.com/877915.
#if 0
        // Since we expect the caller to be fully aware of what is stored, just
        // assert that the caller removes an existing value.
        SkASSERT(list);
        ValueList* prev = nullptr;
        while (list->fValue != value) {
            prev = list;
            list = list->fNext;
        }
        this->internalRemove(prev, list, key);
#else
        ValueList* prev = nullptr;
        while (list && list->fValue != value) {
            prev = list;
            list = list->fNext;
        }
        // Crash in Debug since it'd be great to detect a repro of 877915.
        SkASSERT(list);
        if (list) {
            this->internalRemove(prev, list, key);
        }
#endif
    }

reset()

template<typename T , typename Key , typename HashTraits = T>

void SkTMultiMap< T, Key, HashTraits >::reset ( )

inline

Definition at line 35 of file SkTMultiMap.h.

                 {
        fHash.foreach([&](ValueList* vl) {
            ValueList* next;
            for (ValueList* it = vl; it; it = next) {
                HashTraits::OnFree(it->fValue);
                next = it->fNext;
                delete it;
            }
        });
        fHash.reset();
        fCount = 0;
    }

---

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

• third_party/skia/src/core/SkTMultiMap.h