SkTInternalLList< T > Class Template Reference

#include <SkTInternalLList.h>

Classes
class	Iter

Public Member Functions
	SkTInternalLList ()
void	reset ()
void	remove (T *entry)
void	addToHead (T *entry)
void	addToTail (T *entry)
void	addBefore (T *newEntry, T *existingEntry)
void	addAfter (T *newEntry, T *existingEntry)
void	concat (SkTInternalLList &&list)
bool	isEmpty () const
T *	head () const
T *	tail () const
Iter	begin () const
Iter	end () const

Detailed Description

template<class T>
class SkTInternalLList< T >

This class implements a templated internal doubly linked list data structure.

Definition at line 29 of file SkTInternalLList.h.

Constructor & Destructor Documentation

SkTInternalLList()

template<class T >

SkTInternalLList< T >::SkTInternalLList ( )

inline

Definition at line 31 of file SkTInternalLList.h.

{}

Member Function Documentation

addAfter()

template<class T >

void SkTInternalLList< T >::addAfter ( T *  newEntry, T *  existingEntry  )

inline

Inserts a new list entry after an existing list entry. The new entry must not already be a member of this or any other list. If existingEntry is NULL then the new entry is added at the head.

Definition at line 136 of file SkTInternalLList.h.

                                                 {
        SkASSERT(newEntry);
 
        if (nullptr == existingEntry) {
            this->addToHead(newEntry);
            return;
        }
 
        SkASSERT(this->isInList(existingEntry));
        newEntry->fPrev = existingEntry;
        T* next = existingEntry->fNext;
        existingEntry->fNext = newEntry;
        newEntry->fNext = next;
        if (nullptr == next) {
            SkASSERT(fTail == existingEntry);
            fTail = newEntry;
        } else {
            next->fPrev = newEntry;
        }
#ifdef SK_DEBUG
        newEntry->fList = this;
#endif
    }

addBefore()

template<class T >

void SkTInternalLList< T >::addBefore ( T *  newEntry, T *  existingEntry  )

inline

Inserts a new list entry before an existing list entry. The new entry must not already be a member of this or any other list. If existingEntry is NULL then the new entry is added at the tail.

Definition at line 107 of file SkTInternalLList.h.

                                                  {
        SkASSERT(newEntry);
 
        if (nullptr == existingEntry) {
            this->addToTail(newEntry);
            return;
        }
 
        SkASSERT(this->isInList(existingEntry));
        newEntry->fNext = existingEntry;
        T* prev = existingEntry->fPrev;
        existingEntry->fPrev = newEntry;
        newEntry->fPrev = prev;
        if (nullptr == prev) {
            SkASSERT(fHead == existingEntry);
            fHead = newEntry;
        } else {
            prev->fNext = newEntry;
        }
#ifdef SK_DEBUG
        newEntry->fList = this;
#endif
    }

addToHead()

template<class T >

void SkTInternalLList< T >::addToHead ( T *  entry )

inline

Definition at line 64 of file SkTInternalLList.h.

                             {
        SkASSERT(nullptr == entry->fPrev && nullptr == entry->fNext);
        SkASSERT(nullptr == entry->fList);
 
        entry->fPrev = nullptr;
        entry->fNext = fHead;
        if (fHead) {
            fHead->fPrev = entry;
        }
        fHead = entry;
        if (nullptr == fTail) {
            fTail = entry;
        }
 
#ifdef SK_DEBUG
        entry->fList = this;
#endif
    }

addToTail()

template<class T >

void SkTInternalLList< T >::addToTail ( T *  entry )

inline

Definition at line 83 of file SkTInternalLList.h.

                             {
        SkASSERT(nullptr == entry->fPrev && nullptr == entry->fNext);
        SkASSERT(nullptr == entry->fList);
 
        entry->fPrev = fTail;
        entry->fNext = nullptr;
        if (fTail) {
            fTail->fNext = entry;
        }
        fTail = entry;
        if (nullptr == fHead) {
            fHead = entry;
        }
 
#ifdef SK_DEBUG
        entry->fList = this;
#endif
    }

begin()

template<class T >

Iter SkTInternalLList< T >::begin ( ) const

inline

Definition at line 249 of file SkTInternalLList.h.

                       {
        Iter iter;
        iter.init(*this, Iter::kHead_IterStart);
        return iter;
    }

concat()

template<class T >

void SkTInternalLList< T >::concat ( SkTInternalLList< T > &&  list )

inline

Definition at line 160 of file SkTInternalLList.h.

                                         {
        if (list.isEmpty()) {
            return;
        }
 
        list.fHead->fPrev = fTail;
        if (!fHead) {
            SkASSERT(!list.fHead->fPrev);
            fHead = list.fHead;
        } else {
            SkASSERT(fTail);
            fTail->fNext = list.fHead;
        }
        fTail = list.fTail;
 
#ifdef SK_DEBUG
        for (T* node = list.fHead; node; node = node->fNext) {
            SkASSERT(node->fList == &list);
            node->fList = this;
        }
#endif
 
        list.fHead = list.fTail = nullptr;
    }

end()

template<class T >

Iter SkTInternalLList< T >::end ( ) const

inline

Definition at line 255 of file SkTInternalLList.h.

{ return Iter(); }

head()

template<class T >

T * SkTInternalLList< T >::head ( ) const

inline

Definition at line 190 of file SkTInternalLList.h.

{ return fHead; }

isEmpty()

template<class T >

bool SkTInternalLList< T >::isEmpty ( ) const

inline

Definition at line 185 of file SkTInternalLList.h.

                         {
        SkASSERT(SkToBool(fHead) == SkToBool(fTail));
        return !fHead;
    }

remove()

template<class T >

void SkTInternalLList< T >::remove ( T *  entry )

inline

Definition at line 38 of file SkTInternalLList.h.

                          {
        SkASSERT(fHead && fTail);
        SkASSERT(this->isInList(entry));
 
        T* prev = entry->fPrev;
        T* next = entry->fNext;
 
        if (prev) {
            prev->fNext = next;
        } else {
            fHead = next;
        }
        if (next) {
            next->fPrev = prev;
        } else {
            fTail = prev;
        }
 
        entry->fPrev = nullptr;
        entry->fNext = nullptr;
 
#ifdef SK_DEBUG
        entry->fList = nullptr;
#endif
    }

reset()

template<class T >

void SkTInternalLList< T >::reset ( )

inline

Definition at line 33 of file SkTInternalLList.h.

                 {
        fHead = nullptr;
        fTail = nullptr;
    }

tail()

template<class T >

T * SkTInternalLList< T >::tail ( ) const

inline

Definition at line 191 of file SkTInternalLList.h.

{ return fTail; }

---

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

• third_party/skia/src/base/SkTInternalLList.h