'<(skia_include_path)/core/SkTDArray.h',
'<(skia_include_path)/core/SkTDStack.h',
'<(skia_include_path)/core/SkTDict.h',
- '<(skia_include_path)/core/SkTDLinkedList.h',
+ '<(skia_include_path)/core/SkTInternalLList.h',
'<(skia_include_path)/core/SkTRegistry.h',
'<(skia_include_path)/core/SkTScopedPtr.h',
'<(skia_include_path)/core/SkTSearch.h',
+++ /dev/null
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkTDLinkedList_DEFINED
-#define SkTDLinkedList_DEFINED
-
-#include "SkTypes.h"
-
-/**
- * Helper class to automatically initialize the doubly linked list
- * created pointers.
- */
-template <typename T> class SkPtrWrapper {
- public:
- SkPtrWrapper() : fPtr(NULL) {}
- SkPtrWrapper& operator =(T* ptr) { fPtr = ptr; return *this; }
- operator T*() const { return fPtr; }
- T* operator->() { return fPtr; }
- private:
- T* fPtr;
-};
-
-
-/**
- * This macro creates the member variables required by
- * the SkTDLinkedList class. It should be placed in the private section
- * of any class that will be stored in a double linked list.
- */
-#define SK_DEFINE_DLINKEDLIST_INTERFACE(ClassName) \
- friend class SkTDLinkedList<ClassName>; \
- /* back pointer to the owning list - for debugging */ \
- SkDEBUGCODE(SkPtrWrapper<SkTDLinkedList<ClassName> > fList;)\
- SkPtrWrapper<ClassName> fPrev; \
- SkPtrWrapper<ClassName> fNext;
-
-/**
- * This class implements a templated internal doubly linked list data structure.
- */
-template <class T> class SkTDLinkedList : public SkNoncopyable {
-public:
- SkTDLinkedList()
- : fHead(NULL)
- , fTail(NULL) {
- }
-
- void remove(T* entry) {
- SkASSERT(NULL != fHead && NULL != fTail);
- SkASSERT(this->isInList(entry));
-
- T* prev = entry->fPrev;
- T* next = entry->fNext;
-
- if (NULL != prev) {
- prev->fNext = next;
- } else {
- fHead = next;
- }
- if (NULL != next) {
- next->fPrev = prev;
- } else {
- fTail = prev;
- }
-
- entry->fPrev = NULL;
- entry->fNext = NULL;
-
-#ifdef SK_DEBUG
- entry->fList = NULL;
-#endif
- }
-
- void addToHead(T* entry) {
- SkASSERT(NULL == entry->fPrev && NULL == entry->fNext);
- SkASSERT(NULL == entry->fList);
-
- entry->fPrev = NULL;
- entry->fNext = fHead;
- if (NULL != fHead) {
- fHead->fPrev = entry;
- }
- fHead = entry;
- if (NULL == fTail) {
- fTail = entry;
- }
-
-#ifdef SK_DEBUG
- entry->fList = this;
-#endif
- }
-
- bool isEmpty() const {
- return NULL == fHead && NULL == fTail;
- }
-
- T* head() { return fHead; }
- T* tail() { return fTail; }
-
- class Iter {
- public:
- enum IterStart {
- kHead_IterStart,
- kTail_IterStart
- };
-
- Iter() : fCur(NULL) {}
-
- T* init(SkTDLinkedList& list, IterStart startLoc) {
- if (kHead_IterStart == startLoc) {
- fCur = list.fHead;
- } else {
- SkASSERT(kTail_IterStart == startLoc);
- fCur = list.fTail;
- }
-
- return fCur;
- }
-
- /**
- * Return the next/previous element in the list or NULL if at the end.
- */
- T* next() {
- if (NULL == fCur) {
- return NULL;
- }
-
- fCur = fCur->fNext;
- return fCur;
- }
-
- T* prev() {
- if (NULL == fCur) {
- return NULL;
- }
-
- fCur = fCur->fPrev;
- return fCur;
- }
-
- private:
- T* fCur;
- };
-
-#ifdef SK_DEBUG
- void validate() const {
- GrAssert(!fHead == !fTail);
- }
-
- /**
- * Debugging-only method that uses the list back pointer to check if
- * 'entry' is indeed in 'this' list.
- */
- bool isInList(const T* entry) const {
- return entry->fList == this;
- }
-
- /**
- * Debugging-only method that laboriously counts the list entries.
- */
- int countEntries() const {
- int count = 0;
- for (T* entry = fHead; NULL != entry; entry = entry->fNext) {
- ++count;
- }
- return count;
- }
-#endif // SK_DEBUG
-
-private:
- T* fHead;
- T* fTail;
-
- typedef SkNoncopyable INHERITED;
-};
-
-#endif // SkTDLinkedList_DEFINED
--- /dev/null
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTInternalLList_DEFINED
+#define SkTInternalLList_DEFINED
+
+#include "SkTypes.h"
+
+/**
+ * Helper class to automatically initialize the doubly linked list created pointers.
+ */
+template <typename T> class SkPtrWrapper {
+ public:
+ SkPtrWrapper() : fPtr(NULL) {}
+ SkPtrWrapper& operator =(T* ptr) { fPtr = ptr; return *this; }
+ operator T*() const { return fPtr; }
+ T* operator->() { return fPtr; }
+ private:
+ T* fPtr;
+};
+
+
+/**
+ * This macro creates the member variables required by the SkTInternalLList class. It should be
+ * placed in the private section of any class that will be stored in a double linked list.
+ */
+#define SK_DECLARE_INTERNAL_LLIST_INTERFACE(ClassName) \
+ friend class SkTInternalLList<ClassName>; \
+ /* back pointer to the owning list - for debugging */ \
+ SkDEBUGCODE(SkPtrWrapper<SkTInternalLList<ClassName> > fList;) \
+ SkPtrWrapper<ClassName> fPrev; \
+ SkPtrWrapper<ClassName> fNext
+
+/**
+ * This class implements a templated internal doubly linked list data structure.
+ */
+template <class T> class SkTInternalLList : public SkNoncopyable {
+public:
+ SkTInternalLList()
+ : fHead(NULL)
+ , fTail(NULL) {
+ }
+
+ void remove(T* entry) {
+ SkASSERT(NULL != fHead && NULL != fTail);
+ SkASSERT(this->isInList(entry));
+
+ T* prev = entry->fPrev;
+ T* next = entry->fNext;
+
+ if (NULL != prev) {
+ prev->fNext = next;
+ } else {
+ fHead = next;
+ }
+ if (NULL != next) {
+ next->fPrev = prev;
+ } else {
+ fTail = prev;
+ }
+
+ entry->fPrev = NULL;
+ entry->fNext = NULL;
+
+#ifdef SK_DEBUG
+ entry->fList = NULL;
+#endif
+ }
+
+ void addToHead(T* entry) {
+ SkASSERT(NULL == entry->fPrev && NULL == entry->fNext);
+ SkASSERT(NULL == entry->fList);
+
+ entry->fPrev = NULL;
+ entry->fNext = fHead;
+ if (NULL != fHead) {
+ fHead->fPrev = entry;
+ }
+ fHead = entry;
+ if (NULL == fTail) {
+ fTail = entry;
+ }
+
+#ifdef SK_DEBUG
+ entry->fList = this;
+#endif
+ }
+
+ void addToTail(T* entry) {
+ SkASSERT(NULL == entry->fPrev && NULL == entry->fNext);
+ SkASSERT(NULL == entry->fList);
+
+ entry->fPrev = fTail;
+ entry->fNext = NULL;
+ if (NULL != fTail) {
+ fTail->fNext = entry;
+ }
+ fTail = entry;
+ if (NULL == fHead) {
+ fHead = entry;
+ }
+
+#ifdef SK_DEBUG
+ entry->fList = this;
+#endif
+ }
+
+ bool isEmpty() const {
+ return NULL == fHead && NULL == fTail;
+ }
+
+ T* head() { return fHead; }
+ T* tail() { return fTail; }
+
+ class Iter {
+ public:
+ enum IterStart {
+ kHead_IterStart,
+ kTail_IterStart
+ };
+
+ Iter() : fCurr(NULL) {}
+ Iter(const Iter& iter) : fCurr(iter.fCurr) {}
+ Iter& operator= (const Iter& iter) { fCurr = iter.fCurr; return *this; }
+
+ T* init(const SkTInternalLList& list, IterStart startLoc) {
+ if (kHead_IterStart == startLoc) {
+ fCurr = list.fHead;
+ } else {
+ SkASSERT(kTail_IterStart == startLoc);
+ fCurr = list.fTail;
+ }
+
+ return fCurr;
+ }
+
+ T* get() { return fCurr; }
+
+ /**
+ * Return the next/previous element in the list or NULL if at the end.
+ */
+ T* next() {
+ if (NULL == fCurr) {
+ return NULL;
+ }
+
+ fCurr = fCurr->fNext;
+ return fCurr;
+ }
+
+ T* prev() {
+ if (NULL == fCurr) {
+ return NULL;
+ }
+
+ fCurr = fCurr->fPrev;
+ return fCurr;
+ }
+
+ private:
+ T* fCurr;
+ };
+
+#ifdef SK_DEBUG
+ void validate() const {
+ SkASSERT(!fHead == !fTail);
+ }
+
+ /**
+ * Debugging-only method that uses the list back pointer to check if 'entry' is indeed in 'this'
+ * list.
+ */
+ bool isInList(const T* entry) const {
+ return entry->fList == this;
+ }
+
+ /**
+ * Debugging-only method that laboriously counts the list entries.
+ */
+ int countEntries() const {
+ int count = 0;
+ for (T* entry = fHead; NULL != entry; entry = entry->fNext) {
+ ++count;
+ }
+ return count;
+ }
+#endif // SK_DEBUG
+
+private:
+ T* fHead;
+ T* fTail;
+
+ typedef SkNoncopyable INHERITED;
+};
+
+#endif
#include "GrRefCnt.h"
-#include "SkTDLinkedList.h"
+#include "SkTInternalLList.h"
class GrGpu;
class GrContext;
// release() on all such resources in its
// destructor.
- // we're a dlinklist
- SK_DEFINE_DLINKEDLIST_INTERFACE(GrResource);
+ // We're in an internal doubly linked list
+ SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrResource);
GrResourceEntry* fCacheEntry; // NULL if not in cache
#include "SkCondVar.h"
#include "SkTDArray.h"
-#include "SkTDLinkedList.h"
+#include "SkTInternalLList.h"
class SkRunnable;
class SkThread;
SkRunnable* fRunnable;
private:
- SK_DEFINE_DLINKEDLIST_INTERFACE(LinkedRunnable)
+ SK_DECLARE_INTERNAL_LLIST_INTERFACE(LinkedRunnable);
};
- SkTDLinkedList<LinkedRunnable> fQueue;
- SkCondVar fReady;
- SkTDArray<SkThread*> fThreads;
- bool fDone;
+ SkTInternalLList<LinkedRunnable> fQueue;
+ SkCondVar fReady;
+ SkTDArray<SkThread*> fThreads;
+ bool fDone;
static void Loop(void*); // Static because we pass in this.
};
bool fContextIsDirty;
- typedef SkTDLinkedList<GrResource> ResourceList;
+ typedef SkTInternalLList<GrResource> ResourceList;
ResourceList fResourceList;
// Given a rt, find or create a stencil buffer and attach it
#include "GrConfig.h"
#include "GrTypes.h"
#include "GrTHashCache.h"
-#include "SkTDLinkedList.h"
+#include "SkTInternalLList.h"
class GrResource;
GrResourceKey fKey;
GrResource* fResource;
- // we're a dlinklist
- SK_DEFINE_DLINKEDLIST_INTERFACE(GrResourceEntry);
+ // we're a linked list
+ SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrResourceEntry);
friend class GrResourceCache;
friend class GrDLinkedList;
class Key;
GrTHashTable<GrResourceEntry, Key, 8> fCache;
- // manage the dlink list
- typedef SkTDLinkedList<GrResourceEntry> EntryList;
+ // We're an internal doubly linked list
+ typedef SkTInternalLList<GrResourceEntry> EntryList;
EntryList fList;
#if GR_DEBUG
bool fPurging;
#if GR_DEBUG
- static size_t countBytes(const SkTDLinkedList<GrResourceEntry>& list);
+ static size_t countBytes(const SkTInternalLList<GrResourceEntry>& list);
#endif
};
*/
#include "Test.h"
-#include "SkTDLinkedList.h"
+#include "SkTInternalLList.h"
class ListElement {
public:
int fID;
private:
- SK_DEFINE_DLINKEDLIST_INTERFACE(ListElement);
+ SK_DECLARE_INTERNAL_LLIST_INTERFACE(ListElement);
};
-static void CheckList(const SkTDLinkedList<ListElement>& list,
+static void CheckList(const SkTInternalLList<ListElement>& list,
skiatest::Reporter* reporter,
bool empty,
int numElements,
}
static void TestTDLinkedList(skiatest::Reporter* reporter) {
- SkTDLinkedList<ListElement> list;
+ SkTInternalLList<ListElement> list;
ListElement elements[4] = {
ListElement(0),
ListElement(1),
CheckList(list, reporter, false, 4, true, true, true, true, elements);
// test out iterators
- SkTDLinkedList<ListElement>::Iter iter;
+ typedef SkTInternalLList<ListElement>::Iter Iter;
+ Iter iter;
- ListElement* cur = iter.init(list, SkTDLinkedList<ListElement>::Iter::kHead_IterStart);
+ ListElement* cur = iter.init(list, Iter::kHead_IterStart);
for (int i = 0; NULL != cur; ++i, cur = iter.next()) {
REPORTER_ASSERT(reporter, cur->fID == 3-i);
}
- cur = iter.init(list, SkTDLinkedList<ListElement>::Iter::kTail_IterStart);
+ cur = iter.init(list, Iter::kTail_IterStart);
for (int i = 0; NULL != cur; ++i, cur = iter.prev()) {
REPORTER_ASSERT(reporter, cur->fID == i);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff