skia_private::THashTable< T, K, Traits > Class Template Reference

#include <SkTHash.h>

Classes
class	Iter

Public Member Functions
	THashTable ()=default
	~THashTable ()=default
	THashTable (const THashTable &that)
	THashTable (THashTable &&that)
THashTable &	operator= (const THashTable &that)
THashTable &	operator= (THashTable &&that)
void	reset ()
int	count () const
int	capacity () const
size_t	approxBytesUsed () const
void	swap (THashTable &that)
void	swap (THashTable &&that)
T *	set (T val)
T *	find (const K &key) const
T	findOrNull (const K &key) const
bool	removeIfExists (const K &key)
void	remove (const K &key)
void	resize (int capacity)
template<typename Fn >
void	foreach (Fn &&fn)
template<typename Fn >
void	foreach (Fn &&fn) const

Detailed Description

template<typename T, typename K, typename Traits = T>
class skia_private::THashTable< T, K, Traits >

Definition at line 32 of file SkTHash.h.

Constructor & Destructor Documentation

THashTable() [1/3]

template<typename T , typename K , typename Traits = T>

skia_private::THashTable< T, K, Traits >::THashTable ( )

default

~THashTable()

template<typename T , typename K , typename Traits = T>

skia_private::THashTable< T, K, Traits >::~THashTable ( )

default

THashTable() [2/3]

template<typename T , typename K , typename Traits = T>

skia_private::THashTable< T, K, Traits >::THashTable ( const THashTable< T, K, Traits > &  that )

inline

Definition at line 37 of file SkTHash.h.

{ *this = that; }

THashTable() [3/3]

template<typename T , typename K , typename Traits = T>

skia_private::THashTable< T, K, Traits >::THashTable ( THashTable< T, K, Traits > &&  that )

inline

Definition at line 38 of file SkTHash.h.

{ *this = std::move(that); }

Member Function Documentation

approxBytesUsed()

template<typename T , typename K , typename Traits = T>

size_t skia_private::THashTable< T, K, Traits >::approxBytesUsed ( ) const

inline

Definition at line 74 of file SkTHash.h.

{ return fCapacity * sizeof(Slot); }

capacity()

template<typename T , typename K , typename Traits = T>

int skia_private::THashTable< T, K, Traits >::capacity ( ) const

inline

Definition at line 71 of file SkTHash.h.

{ return fCapacity; }

count()

template<typename T , typename K , typename Traits = T>

int skia_private::THashTable< T, K, Traits >::count ( ) const

inline

Definition at line 67 of file SkTHash.h.

{ return fCount; }

find()

template<typename T , typename K , typename Traits = T>

T * skia_private::THashTable< T, K, Traits >::find ( const K &  key ) const

inline

Definition at line 107 of file SkTHash.h.

                                {
        uint32_t hash = Hash(key);
        int index = hash & (fCapacity-1);
        for (int n = 0; n < fCapacity; n++) {
            Slot& s = fSlots[index];
            if (s.empty()) {
                return nullptr;
            }
            if (hash == s.fHash && key == Traits::GetKey(*s)) {
                return &*s;
            }
            index = this->next(index);
        }
        SkASSERT(fCapacity == fCount);
        return nullptr;
    }

findOrNull()

template<typename T , typename K , typename Traits = T>

T skia_private::THashTable< T, K, Traits >::findOrNull ( const K &  key ) const

inline

Definition at line 126 of file SkTHash.h.

                                     {
        if (T* p = this->find(key)) {
            return *p;
        }
        return nullptr;
    }

foreach() [1/2]

template<typename T , typename K , typename Traits = T>

template<typename Fn >

void skia_private::THashTable< T, K, Traits >::foreach ( Fn &&  fn )

inline

Definition at line 184 of file SkTHash.h.

                          {
        for (int i = 0; i < fCapacity; i++) {
            if (fSlots[i].has_value()) {
                fn(&*fSlots[i]);
            }
        }
    }

foreach() [2/2]

template<typename T , typename K , typename Traits = T>

template<typename Fn >

void skia_private::THashTable< T, K, Traits >::foreach ( Fn &&  fn ) const

inline

Definition at line 194 of file SkTHash.h.

                                {
        for (int i = 0; i < fCapacity; i++) {
            if (fSlots[i].has_value()) {
                fn(*fSlots[i]);
            }
        }
    }

operator=() [1/2]

template<typename T , typename K , typename Traits = T>

THashTable & skia_private::THashTable< T, K, Traits >::operator= ( const THashTable< T, K, Traits > &  that )

inline

Definition at line 40 of file SkTHash.h.

                                                  {
        if (this != &that) {
            fCount     = that.fCount;
            fCapacity  = that.fCapacity;
            fSlots.reset(new Slot[that.fCapacity]);
            for (int i = 0; i < fCapacity; i++) {
                fSlots[i] = that.fSlots[i];
            }
        }
        return *this;
    }

operator=() [2/2]

template<typename T , typename K , typename Traits = T>

THashTable & skia_private::THashTable< T, K, Traits >::operator= ( THashTable< T, K, Traits > &&  that )

inline

Definition at line 52 of file SkTHash.h.

                                             {
        if (this != &that) {
            fCount    = that.fCount;
            fCapacity = that.fCapacity;
            fSlots    = std::move(that.fSlots);
 
            that.fCount = that.fCapacity = 0;
        }
        return *this;
    }

remove()

template<typename T , typename K , typename Traits = T>

void skia_private::THashTable< T, K, Traits >::remove ( const K &  key )

inline

Definition at line 157 of file SkTHash.h.

                              {
        SkAssertResult(this->removeIfExists(key));
    }

removeIfExists()

template<typename T , typename K , typename Traits = T>

bool skia_private::THashTable< T, K, Traits >::removeIfExists ( const K &  key )

inline

Definition at line 135 of file SkTHash.h.

                                      {
        uint32_t hash = Hash(key);
        int index = hash & (fCapacity-1);
        for (int n = 0; n < fCapacity; n++) {
            Slot& s = fSlots[index];
            if (s.empty()) {
                return false;
            }
            if (hash == s.fHash && key == Traits::GetKey(*s)) {
               this->removeSlot(index);
               if (4 * fCount <= fCapacity && fCapacity > 4) {
                   this->resize(fCapacity / 2);
               }
               return true;
            }
            index = this->next(index);
        }
        SkASSERT(fCapacity == fCount);
        return false;
    }

reset()

template<typename T , typename K , typename Traits = T>

void skia_private::THashTable< T, K, Traits >::reset ( )

inline

Definition at line 64 of file SkTHash.h.

{ *this = THashTable(); }

resize()

template<typename T , typename K , typename Traits = T>

void skia_private::THashTable< T, K, Traits >::resize ( int  capacity )

inline

Definition at line 163 of file SkTHash.h.

                              {
        SkASSERT(capacity >= fCount);
        int oldCapacity = fCapacity;
        SkDEBUGCODE(int oldCount = fCount);
 
        fCount = 0;
        fCapacity = capacity;
        std::unique_ptr<Slot[]> oldSlots = std::move(fSlots);
        fSlots.reset(new Slot[capacity]);
 
        for (int i = 0; i < oldCapacity; i++) {
            Slot& s = oldSlots[i];
            if (s.has_value()) {
                this->uncheckedSet(*std::move(s));
            }
        }
        SkASSERT(fCount == oldCount);
    }

set()

template<typename T , typename K , typename Traits = T>

T * skia_private::THashTable< T, K, Traits >::set ( T  val )

inline

Definition at line 99 of file SkTHash.h.

                  {
        if (4 * fCount >= 3 * fCapacity) {
            this->resize(fCapacity > 0 ? fCapacity * 2 : 4);
        }
        return this->uncheckedSet(std::move(val));
    }

swap() [1/2]

template<typename T , typename K , typename Traits = T>

void skia_private::THashTable< T, K, Traits >::swap ( THashTable< T, K, Traits > &&  that )

inline

Definition at line 83 of file SkTHash.h.

                                 {
        *this = std::move(that);
    }

swap() [2/2]

template<typename T , typename K , typename Traits = T>

void skia_private::THashTable< T, K, Traits >::swap ( THashTable< T, K, Traits > &  that )

inline

Definition at line 77 of file SkTHash.h.

                                {
        std::swap(fCount, that.fCount);
        std::swap(fCapacity, that.fCapacity);
        std::swap(fSlots, that.fSlots);
    }

---

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

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