summaryrefslogtreecommitdiffstats
path: root/libs
diff options
context:
space:
mode:
Diffstat (limited to 'libs')
-rw-r--r--libs/hwui/Android.mk1
-rw-r--r--libs/hwui/GenerationCache.h201
-rw-r--r--libs/hwui/LayerCache.cpp5
-rw-r--r--libs/hwui/LayerCache.h2
-rw-r--r--libs/hwui/OpenGLRenderer.cpp2
-rw-r--r--libs/hwui/SortedList.cpp126
-rw-r--r--libs/hwui/SortedList.h255
-rw-r--r--libs/hwui/TextureCache.cpp2
-rw-r--r--libs/hwui/TextureCache.h2
9 files changed, 541 insertions, 55 deletions
diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk
index 394aeca..cbdbc3c 100644
--- a/libs/hwui/Android.mk
+++ b/libs/hwui/Android.mk
@@ -6,6 +6,7 @@ LOCAL_SRC_FILES:= \
Matrix.cpp \
OpenGLRenderer.cpp \
Program.cpp \
+ SortedList.cpp \
TextureCache.cpp
LOCAL_C_INCLUDES += \
diff --git a/libs/hwui/GenerationCache.h b/libs/hwui/GenerationCache.h
index d92a0bb..5f64a35 100644
--- a/libs/hwui/GenerationCache.h
+++ b/libs/hwui/GenerationCache.h
@@ -20,9 +20,68 @@
#include <utils/KeyedVector.h>
#include <utils/RefBase.h>
+#include "SortedList.h"
+
namespace android {
namespace uirenderer {
+template<typename K, typename V>
+class GenerationCacheStorage {
+public:
+ virtual ~GenerationCacheStorage();
+
+ virtual size_t size() const = 0;
+ virtual void clear() = 0;
+ virtual ssize_t add(const K& key, const V& item) = 0;
+ virtual ssize_t indexOfKey(const K& key) const = 0;
+ virtual const V& valueAt(size_t index) const = 0;
+ virtual ssize_t removeItemsAt(size_t index, size_t count) = 0;
+}; // GenerationCacheStorage
+
+template<typename K, typename V>
+GenerationCacheStorage<K, V>::~GenerationCacheStorage() {
+}
+
+template<typename K, typename V>
+class KeyedVectorStorage: public GenerationCacheStorage<K, V> {
+public:
+ KeyedVectorStorage() { }
+ ~KeyedVectorStorage() { }
+
+ inline size_t size() const { return mStorage.size(); }
+ inline void clear() { mStorage.clear(); }
+ inline ssize_t add(const K& key, const V& value) { return mStorage.add(key, value); }
+ inline ssize_t indexOfKey(const K& key) const { return mStorage.indexOfKey(key); }
+ inline const V& valueAt(size_t index) const { return mStorage.valueAt(index); }
+ inline ssize_t removeItemsAt(size_t index, size_t count) {
+ return mStorage.removeItemsAt(index, count);
+ }
+private:
+ KeyedVector<K, V> mStorage;
+}; // class KeyedVectorStorage
+
+template<typename K, typename V>
+class SortedListStorage: public GenerationCacheStorage<K, V> {
+public:
+ SortedListStorage() { }
+ ~SortedListStorage() { }
+
+ inline size_t size() const { return mStorage.size(); }
+ inline void clear() { mStorage.clear(); }
+ inline ssize_t add(const K& key, const V& value) {
+ return mStorage.add(key_value_pair_t<K, V>(key, value));
+ }
+ inline ssize_t indexOfKey(const K& key) const {
+ return mStorage.indexOf(key_value_pair_t<K, V>(key));
+ }
+ inline const V& valueAt(size_t index) const { return mStorage.itemAt(index).value; }
+ inline ssize_t removeItemsAt(size_t index, size_t count) {
+ return mStorage.removeItemsAt(index, count);
+ }
+private:
+ SortedList<key_value_pair_t<K, V> > mStorage;
+}; // class SortedListStorage
+
template<typename EntryKey, typename EntryValue>
class OnEntryRemoved {
public:
@@ -30,11 +89,27 @@ public:
virtual void operator()(EntryKey& key, EntryValue& value) = 0;
}; // class OnEntryRemoved
+template<typename EntryKey, typename EntryValue>
+struct Entry: public LightRefBase<Entry<EntryKey, EntryValue> > {
+ Entry() { }
+ Entry(const Entry<EntryKey, EntryValue>& e):
+ key(e.key), value(e.value), index(e.index), parent(e.parent), child(e.child) { }
+ Entry(sp<Entry<EntryKey, EntryValue> > e):
+ key(e->key), value(e->value), index(e->index), parent(e->parent), child(e->child) { }
+
+ EntryKey key;
+ EntryValue value;
+ ssize_t index;
+
+ sp<Entry<EntryKey, EntryValue> > parent;
+ sp<Entry<EntryKey, EntryValue> > child;
+}; // struct Entry
+
template<typename K, typename V>
class GenerationCache {
public:
- GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCapacity), mListener(NULL) { };
- ~GenerationCache() { clear(); };
+ GenerationCache(uint32_t maxCapacity);
+ virtual ~GenerationCache();
enum Capacity {
kUnlimitedCapacity,
@@ -52,39 +127,64 @@ public:
uint32_t size() const;
-private:
- template<typename EntryKey, typename EntryValue>
- struct Entry: public LightRefBase<Entry<EntryKey, EntryValue> > {
- Entry() { }
- Entry(const Entry<EntryKey, EntryValue>& e):
- key(e.key), value(e.value), parent(e.parent), child(e.child) { }
- Entry(sp<Entry<EntryKey, EntryValue> > e):
- key(e->key), value(e->value), parent(e->parent), child(e->child) { }
-
- EntryKey key;
- EntryValue value;
-
- sp<Entry<EntryKey, EntryValue> > parent;
- sp<Entry<EntryKey, EntryValue> > child;
- }; // struct Entry
+protected:
+ virtual GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() = 0;
+ GenerationCacheStorage<K, sp<Entry<K, V> > >* mCache;
+private:
void addToCache(sp<Entry<K, V> > entry, K key, V value);
void attachToCache(sp<Entry<K, V> > entry);
void detachFromCache(sp<Entry<K, V> > entry);
+ V removeAt(ssize_t index);
+
uint32_t mMaxCapacity;
OnEntryRemoved<K, V>* mListener;
- KeyedVector<K, sp<Entry<K, V> > > mCache;
-
sp<Entry<K, V> > mOldest;
- sp<Entry<K, V> > mYougest;
+ sp<Entry<K, V> > mYoungest;
}; // class GenerationCache
template<typename K, typename V>
+class GenerationSingleCache: public GenerationCache<K, V> {
+public:
+ GenerationSingleCache(uint32_t maxCapacity): GenerationCache<K, V>(maxCapacity) {
+ GenerationCache<K, V>::mCache = createStorage();
+ };
+ ~GenerationSingleCache() { }
+protected:
+ GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() {
+ return new KeyedVectorStorage<K, sp<Entry<K, V> > >;
+ }
+}; // GenerationSingleCache
+
+template<typename K, typename V>
+class GenerationMultiCache: public GenerationCache<K, V> {
+public:
+ GenerationMultiCache(uint32_t maxCapacity): GenerationCache<K, V>(maxCapacity) {
+ GenerationCache<K, V>::mCache = createStorage();
+ };
+ ~GenerationMultiCache() { }
+protected:
+ GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() {
+ return new SortedListStorage<K, sp<Entry<K, V> > >;
+ }
+}; // GenerationMultiCache
+
+template<typename K, typename V>
+GenerationCache<K, V>::GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCapacity), mListener(NULL) {
+};
+
+template<typename K, typename V>
+GenerationCache<K, V>::~GenerationCache() {
+ clear();
+ delete mCache;
+};
+
+template<typename K, typename V>
uint32_t GenerationCache<K, V>::size() const {
- return mCache.size();
+ return mCache->size();
}
template<typename K, typename V>
@@ -95,26 +195,26 @@ void GenerationCache<K, V>::setOnEntryRemovedListener(OnEntryRemoved<K, V>* list
template<typename K, typename V>
void GenerationCache<K, V>::clear() {
if (mListener) {
- while (mCache.size() > 0) {
+ while (mCache->size() > 0) {
removeOldest();
}
} else {
- mCache.clear();
+ mCache->clear();
}
- mYougest.clear();
+ mYoungest.clear();
mOldest.clear();
}
template<typename K, typename V>
bool GenerationCache<K, V>::contains(K key) const {
- return mCache.indexOfKey(key) >= 0;
+ return mCache->indexOfKey(key) >= 0;
}
template<typename K, typename V>
V GenerationCache<K, V>::get(K key) {
- ssize_t index = mCache.indexOfKey(key);
+ ssize_t index = mCache->indexOfKey(key);
if (index >= 0) {
- sp<Entry<K, V> > entry = mCache.valueAt(index);
+ sp<Entry<K, V> > entry = mCache->valueAt(index);
if (entry.get()) {
detachFromCache(entry);
attachToCache(entry);
@@ -127,13 +227,13 @@ V GenerationCache<K, V>::get(K key) {
template<typename K, typename V>
void GenerationCache<K, V>::put(K key, V value) {
- if (mMaxCapacity != kUnlimitedCapacity && mCache.size() >= mMaxCapacity) {
+ if (mMaxCapacity != kUnlimitedCapacity && mCache->size() >= mMaxCapacity) {
removeOldest();
}
- ssize_t index = mCache.indexOfKey(key);
+ ssize_t index = mCache->indexOfKey(key);
if (index >= 0) {
- sp<Entry<K, V> > entry = mCache.valueAt(index);
+ sp<Entry<K, V> > entry = mCache->valueAt(index);
detachFromCache(entry);
addToCache(entry, key, value);
} else {
@@ -146,31 +246,36 @@ template<typename K, typename V>
void GenerationCache<K, V>::addToCache(sp<Entry<K, V> > entry, K key, V value) {
entry->key = key;
entry->value = value;
- mCache.add(key, entry);
+ entry->index = mCache->add(key, entry);
attachToCache(entry);
}
template<typename K, typename V>
V GenerationCache<K, V>::remove(K key) {
- ssize_t index = mCache.indexOfKey(key);
+ ssize_t index = mCache->indexOfKey(key);
if (index >= 0) {
- sp<Entry<K, V> > entry = mCache.valueAt(index);
- if (mListener) {
- (*mListener)(entry->key, entry->value);
- }
- mCache.removeItemsAt(index, 1);
- detachFromCache(entry);
-
- return entry->value;
+ return removeAt(index);
}
return NULL;
}
template<typename K, typename V>
+V GenerationCache<K, V>::removeAt(ssize_t index) {
+ sp<Entry<K, V> > entry = mCache->valueAt(index);
+ if (mListener) {
+ (*mListener)(entry->key, entry->value);
+ }
+ mCache->removeItemsAt(index, 1);
+ detachFromCache(entry);
+
+ return entry->value;
+}
+
+template<typename K, typename V>
V GenerationCache<K, V>::removeOldest() {
if (mOldest.get()) {
- return remove(mOldest->key);
+ return removeAt(mOldest->index);
}
return NULL;
@@ -178,12 +283,12 @@ V GenerationCache<K, V>::removeOldest() {
template<typename K, typename V>
void GenerationCache<K, V>::attachToCache(sp<Entry<K, V> > entry) {
- if (!mYougest.get()) {
- mYougest = mOldest = entry;
+ if (!mYoungest.get()) {
+ mYoungest = mOldest = entry;
} else {
- entry->parent = mYougest;
- mYougest->child = entry;
- mYougest = entry;
+ entry->parent = mYoungest;
+ mYoungest->child = entry;
+ mYoungest = entry;
}
}
@@ -201,8 +306,8 @@ void GenerationCache<K, V>::detachFromCache(sp<Entry<K, V> > entry) {
mOldest = entry->child;
}
- if (mYougest == entry) {
- mYougest = entry->parent;
+ if (mYoungest == entry) {
+ mYoungest = entry->parent;
}
entry->parent.clear();
diff --git a/libs/hwui/LayerCache.cpp b/libs/hwui/LayerCache.cpp
index 0d3214d..7d85e7b 100644
--- a/libs/hwui/LayerCache.cpp
+++ b/libs/hwui/LayerCache.cpp
@@ -28,13 +28,12 @@ namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
LayerCache::LayerCache(uint32_t maxByteSize):
- mCache(GenerationCache<LayerSize, Layer*>::kUnlimitedCapacity),
+ mCache(GenerationMultiCache<LayerSize, Layer*>::kUnlimitedCapacity),
mSize(0), mMaxSize(maxByteSize) {
}
LayerCache::~LayerCache() {
- mCache.setOnEntryRemovedListener(this);
- mCache.clear();
+ clear();
}
///////////////////////////////////////////////////////////////////////////////
diff --git a/libs/hwui/LayerCache.h b/libs/hwui/LayerCache.h
index 3696848..2d339fa 100644
--- a/libs/hwui/LayerCache.h
+++ b/libs/hwui/LayerCache.h
@@ -66,7 +66,7 @@ public:
private:
void deleteLayer(Layer* layer);
- GenerationCache<LayerSize, Layer*> mCache;
+ GenerationMultiCache<LayerSize, Layer*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 9f2cc24..0ade173 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -52,7 +52,7 @@ namespace uirenderer {
#define FV(x, y, u, v) { { x, y }, { u, v } }
// Debug
-#ifdef DEBUG_LAYERS
+#if DEBUG_LAYERS
#define LAYER_LOGD(...) LOGD(__VA_ARGS__)
#else
#define LAYER_LOGD(...)
diff --git a/libs/hwui/SortedList.cpp b/libs/hwui/SortedList.cpp
new file mode 100644
index 0000000..05adff5
--- /dev/null
+++ b/libs/hwui/SortedList.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SortedList.h"
+
+namespace android {
+namespace uirenderer {
+
+SortedListImpl::SortedListImpl(size_t itemSize, uint32_t flags) :
+ VectorImpl(itemSize, flags) {
+}
+
+SortedListImpl::SortedListImpl(const VectorImpl& rhs) :
+ VectorImpl(rhs) {
+}
+
+SortedListImpl::~SortedListImpl() {
+}
+
+SortedListImpl& SortedListImpl::operator =(const SortedListImpl& rhs) {
+ return static_cast<SortedListImpl&> (VectorImpl::operator =(
+ static_cast<const VectorImpl&> (rhs)));
+}
+
+ssize_t SortedListImpl::indexOf(const void* item) const {
+ return _indexOrderOf(item);
+}
+
+size_t SortedListImpl::orderOf(const void* item) const {
+ size_t o;
+ _indexOrderOf(item, &o);
+ return o;
+}
+
+ssize_t SortedListImpl::_indexOrderOf(const void* item, size_t* order) const {
+ // binary search
+ ssize_t err = NAME_NOT_FOUND;
+ ssize_t l = 0;
+ ssize_t h = size() - 1;
+ ssize_t mid;
+ const void* a = arrayImpl();
+ const size_t s = itemSize();
+ while (l <= h) {
+ mid = l + (h - l) / 2;
+ const void* const curr = reinterpret_cast<const char *> (a) + (mid * s);
+ const int c = do_compare(curr, item);
+ if (c == 0) {
+ err = l = mid;
+ break;
+ } else if (c < 0) {
+ l = mid + 1;
+ } else {
+ h = mid - 1;
+ }
+ }
+ if (order)
+ *order = l;
+ return err;
+}
+
+ssize_t SortedListImpl::add(const void* item) {
+ size_t order;
+ ssize_t index = _indexOrderOf(item, &order);
+ index = VectorImpl::insertAt(item, order, 1);
+ return index;
+}
+
+ssize_t SortedListImpl::merge(const VectorImpl& vector) {
+ // naive merge...
+ if (!vector.isEmpty()) {
+ const void* buffer = vector.arrayImpl();
+ const size_t is = itemSize();
+ size_t s = vector.size();
+ for (size_t i = 0; i < s; i++) {
+ ssize_t err = add(reinterpret_cast<const char*> (buffer) + i * is);
+ if (err < 0) {
+ return err;
+ }
+ }
+ }
+ return NO_ERROR;
+}
+
+ssize_t SortedListImpl::merge(const SortedListImpl& vector) {
+ // we've merging a sorted vector... nice!
+ ssize_t err = NO_ERROR;
+ if (!vector.isEmpty()) {
+ // first take care of the case where the vectors are sorted together
+ if (do_compare(vector.itemLocation(vector.size() - 1), arrayImpl()) <= 0) {
+ err = VectorImpl::insertVectorAt(static_cast<const VectorImpl&> (vector), 0);
+ } else if (do_compare(vector.arrayImpl(), itemLocation(size() - 1)) >= 0) {
+ err = VectorImpl::appendVector(static_cast<const VectorImpl&> (vector));
+ } else {
+ // this could be made a little better
+ err = merge(static_cast<const VectorImpl&> (vector));
+ }
+ }
+ return err;
+}
+
+ssize_t SortedListImpl::remove(const void* item) {
+ ssize_t i = indexOf(item);
+ if (i >= 0) {
+ VectorImpl::removeItemsAt(i, 1);
+ }
+ return i;
+}
+
+}
+; // namespace uirenderer
+}
+; // namespace android
+
diff --git a/libs/hwui/SortedList.h b/libs/hwui/SortedList.h
new file mode 100644
index 0000000..13cb64d
--- /dev/null
+++ b/libs/hwui/SortedList.h
@@ -0,0 +1,255 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_UI_SORTED_LIST_H
+#define ANDROID_UI_SORTED_LIST_H
+
+#include <utils/Vector.h>
+#include <utils/VectorImpl.h>
+
+namespace android {
+namespace uirenderer {
+
+class SortedListImpl: public VectorImpl {
+public:
+ SortedListImpl(size_t itemSize, uint32_t flags);
+ SortedListImpl(const VectorImpl& rhs);
+ virtual ~SortedListImpl();
+
+ SortedListImpl& operator =(const SortedListImpl& rhs);
+
+ ssize_t indexOf(const void* item) const;
+ size_t orderOf(const void* item) const;
+ ssize_t add(const void* item);
+ ssize_t merge(const VectorImpl& vector);
+ ssize_t merge(const SortedListImpl& vector);
+ ssize_t remove(const void* item);
+
+protected:
+ virtual int do_compare(const void* lhs, const void* rhs) const = 0;
+
+private:
+ ssize_t _indexOrderOf(const void* item, size_t* order = 0) const;
+
+ // these are made private, because they can't be used on a SortedList
+ // (they don't have an implementation either)
+ ssize_t add();
+ void pop();
+ void push();
+ void push(const void* item);
+ ssize_t insertVectorAt(const VectorImpl& vector, size_t index);
+ ssize_t appendVector(const VectorImpl& vector);
+ ssize_t insertArrayAt(const void* array, size_t index, size_t length);
+ ssize_t appendArray(const void* array, size_t length);
+ ssize_t insertAt(size_t where, size_t numItems = 1);
+ ssize_t insertAt(const void* item, size_t where, size_t numItems = 1);
+ ssize_t replaceAt(size_t index);
+ ssize_t replaceAt(const void* item, size_t index);
+}; // class SortedListImpl
+
+template<class TYPE>
+class SortedList: private SortedListImpl {
+public:
+ typedef TYPE value_type;
+
+ SortedList();
+ SortedList(const SortedList<TYPE>& rhs);
+ virtual ~SortedList();
+
+ const SortedList<TYPE>& operator =(const SortedList<TYPE>& rhs) const;
+ SortedList<TYPE>& operator =(const SortedList<TYPE>& rhs);
+
+ inline void clear() {
+ VectorImpl::clear();
+ }
+
+ inline size_t size() const {
+ return VectorImpl::size();
+ }
+
+ inline bool isEmpty() const {
+ return VectorImpl::isEmpty();
+ }
+
+ inline size_t capacity() const {
+ return VectorImpl::capacity();
+ }
+
+ inline ssize_t setCapacity(size_t size) {
+ return VectorImpl::setCapacity(size);
+ }
+
+ inline const TYPE* array() const;
+
+ TYPE* editArray();
+
+ ssize_t indexOf(const TYPE& item) const;
+
+ size_t orderOf(const TYPE& item) const;
+
+ inline const TYPE& operator [](size_t index) const;
+ inline const TYPE& itemAt(size_t index) const;
+ const TYPE& top() const;
+ const TYPE& mirrorItemAt(ssize_t index) const;
+
+ ssize_t add(const TYPE& item);
+
+ TYPE& editItemAt(size_t index) {
+ return *(static_cast<TYPE *> (VectorImpl::editItemLocation(index)));
+ }
+
+ ssize_t merge(const Vector<TYPE>& vector);
+ ssize_t merge(const SortedList<TYPE>& vector);
+
+ ssize_t remove(const TYPE&);
+
+ inline ssize_t removeItemsAt(size_t index, size_t count = 1);
+ inline ssize_t removeAt(size_t index) {
+ return removeItemsAt(index);
+ }
+
+protected:
+ virtual void do_construct(void* storage, size_t num) const;
+ virtual void do_destroy(void* storage, size_t num) const;
+ virtual void do_copy(void* dest, const void* from, size_t num) const;
+ virtual void do_splat(void* dest, const void* item, size_t num) const;
+ virtual void do_move_forward(void* dest, const void* from, size_t num) const;
+ virtual void
+ do_move_backward(void* dest, const void* from, size_t num) const;
+ virtual int do_compare(const void* lhs, const void* rhs) const;
+};
+
+template<class TYPE> inline SortedList<TYPE>::SortedList() :
+ SortedListImpl(sizeof(TYPE), ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
+ | (traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
+ | (traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))) {
+}
+
+template<class TYPE> inline SortedList<TYPE>::SortedList(const SortedList<TYPE>& rhs) :
+ SortedListImpl(rhs) {
+}
+
+template<class TYPE> inline SortedList<TYPE>::~SortedList() {
+ finish_vector();
+}
+
+template<class TYPE> inline SortedList<TYPE>& SortedList<TYPE>::operator =(
+ const SortedList<TYPE>& rhs) {
+ SortedListImpl::operator =(rhs);
+ return *this;
+}
+
+template<class TYPE> inline const SortedList<TYPE>& SortedList<TYPE>::operator =(const SortedList<
+ TYPE>& rhs) const {
+ SortedListImpl::operator =(rhs);
+ return *this;
+}
+
+template<class TYPE> inline const TYPE* SortedList<TYPE>::array() const {
+ return static_cast<const TYPE *> (arrayImpl());
+}
+
+template<class TYPE> inline TYPE* SortedList<TYPE>::editArray() {
+ return static_cast<TYPE *> (editArrayImpl());
+}
+
+template<class TYPE> inline const TYPE& SortedList<TYPE>::operator[](size_t index) const {
+ assert( index<size() );
+ return *(array() + index);
+}
+
+template<class TYPE> inline const TYPE& SortedList<TYPE>::itemAt(size_t index) const {
+ return operator[](index);
+}
+
+template<class TYPE> inline const TYPE& SortedList<TYPE>::mirrorItemAt(ssize_t index) const {
+ assert( (index>0 ? index : -index)<size() );
+ return *(array() + ((index < 0) ? (size() - index) : index));
+}
+
+template<class TYPE> inline const TYPE& SortedList<TYPE>::top() const {
+ return *(array() + size() - 1);
+}
+
+template<class TYPE> inline ssize_t SortedList<TYPE>::add(const TYPE& item) {
+ return SortedListImpl::add(&item);
+}
+
+template<class TYPE> inline ssize_t SortedList<TYPE>::indexOf(const TYPE& item) const {
+ return SortedListImpl::indexOf(&item);
+}
+
+template<class TYPE> inline size_t SortedList<TYPE>::orderOf(const TYPE& item) const {
+ return SortedListImpl::orderOf(&item);
+}
+
+template<class TYPE> inline ssize_t SortedList<TYPE>::merge(const Vector<TYPE>& vector) {
+ return SortedListImpl::merge(reinterpret_cast<const VectorImpl&> (vector));
+}
+
+template<class TYPE> inline ssize_t SortedList<TYPE>::merge(const SortedList<TYPE>& vector) {
+ return SortedListImpl::merge(reinterpret_cast<const SortedListImpl&> (vector));
+}
+
+template<class TYPE> inline ssize_t SortedList<TYPE>::remove(const TYPE& item) {
+ return SortedListImpl::remove(&item);
+}
+
+template<class TYPE> inline ssize_t SortedList<TYPE>::removeItemsAt(size_t index, size_t count) {
+ return VectorImpl::removeItemsAt(index, count);
+}
+
+template<class TYPE>
+void SortedList<TYPE>::do_construct(void* storage, size_t num) const {
+ construct_type(reinterpret_cast<TYPE*> (storage), num);
+}
+
+template<class TYPE>
+void SortedList<TYPE>::do_destroy(void* storage, size_t num) const {
+ destroy_type(reinterpret_cast<TYPE*> (storage), num);
+}
+
+template<class TYPE>
+void SortedList<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
+ copy_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
+}
+
+template<class TYPE>
+void SortedList<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
+ splat_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (item), num);
+}
+
+template<class TYPE>
+void SortedList<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
+ move_forward_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
+}
+
+template<class TYPE>
+void SortedList<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
+ move_backward_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
+}
+
+template<class TYPE>
+int SortedList<TYPE>::do_compare(const void* lhs, const void* rhs) const {
+ return compare_type(*reinterpret_cast<const TYPE*> (lhs), *reinterpret_cast<const TYPE*> (rhs));
+}
+
+}
+; // namespace uirenderer
+}
+; // namespace android
+
+#endif // ANDROID_UI_SORTED_LIST_H
diff --git a/libs/hwui/TextureCache.cpp b/libs/hwui/TextureCache.cpp
index 612f04e..460284e 100644
--- a/libs/hwui/TextureCache.cpp
+++ b/libs/hwui/TextureCache.cpp
@@ -28,7 +28,7 @@ namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
TextureCache::TextureCache(uint32_t maxByteSize):
- mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
+ mCache(GenerationSingleCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(maxByteSize) {
mCache.setOnEntryRemovedListener(this);
}
diff --git a/libs/hwui/TextureCache.h b/libs/hwui/TextureCache.h
index bed1191..a620876 100644
--- a/libs/hwui/TextureCache.h
+++ b/libs/hwui/TextureCache.h
@@ -78,7 +78,7 @@ private:
*/
void generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate = false);
- GenerationCache<SkBitmap*, Texture*> mCache;
+ GenerationSingleCache<SkBitmap*, Texture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
generated by cgit v1.1 at 2025-03-15 10:20:40 +0000