1 /* libs/graphics/animator/SkTypedArray.cpp 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #include "SkTypedArray.h" 19 20 SkTypedArray::SkTypedArray() : fType(SkType_Unknown) { 21 } 22 23 SkTypedArray::SkTypedArray(SkDisplayTypes type) : fType(type) { 24 } 25 26 bool SkTypedArray::getIndex(int index, SkOperand* operand) { 27 if (index >= count()) { 28 SkASSERT(0); 29 return false; 30 } 31 *operand = begin()[index]; 32 return true; 33 } 34 35 36 #if SK_SMALLER_ARRAY_TEMPLATE_EXPERIMENT == 1 37 SkDS32Array::SkDS32Array() 38 { 39 fReserve = fCount = 0; 40 fArray = NULL; 41 #ifdef SK_DEBUG 42 fData = NULL; 43 #endif 44 } 45 46 SkDS32Array::SkDS32Array(const SkDS32Array& src) 47 { 48 fReserve = fCount = 0; 49 fArray = NULL; 50 #ifdef SK_DEBUG 51 fData = NULL; 52 #endif 53 SkDS32Array tmp(src.fArray, src.fCount); 54 this->swap(tmp); 55 } 56 57 SkDS32Array::SkDS32Array(const int32_t src[], U16CPU count) 58 { 59 SkASSERT(src || count == 0); 60 61 fReserve = fCount = 0; 62 fArray = NULL; 63 #ifdef SK_DEBUG 64 fData = NULL; 65 #endif 66 if (count) 67 { 68 fArray = (int32_t*)sk_malloc_throw(count * sizeof(int32_t)); 69 #ifdef SK_DEBUG 70 fData = (int32_t (*)[kDebugArraySize]) fArray; 71 #endif 72 memcpy(fArray, src, sizeof(int32_t) * count); 73 fReserve = fCount = SkToU16(count); 74 } 75 } 76 77 SkDS32Array& SkDS32Array::operator=(const SkDS32Array& src) 78 { 79 if (this != &src) 80 { 81 if (src.fCount > fReserve) 82 { 83 SkDS32Array tmp(src.fArray, src.fCount); 84 this->swap(tmp); 85 } 86 else 87 { 88 memcpy(fArray, src.fArray, sizeof(int32_t) * src.fCount); 89 fCount = src.fCount; 90 } 91 } 92 return *this; 93 } 94 95 int operator==(const SkDS32Array& a, const SkDS32Array& b) 96 { 97 return a.fCount == b.fCount && 98 (a.fCount == 0 || !memcmp(a.fArray, b.fArray, a.fCount * sizeof(int32_t))); 99 } 100 101 void SkDS32Array::swap(SkDS32Array& other) 102 { 103 SkTSwap(fArray, other.fArray); 104 #ifdef SK_DEBUG 105 SkTSwap(fData, other.fData); 106 #endif 107 SkTSwap(fReserve, other.fReserve); 108 SkTSwap(fCount, other.fCount); 109 } 110 111 int32_t* SkDS32Array::append(U16CPU count, const int32_t* src) 112 { 113 unsigned oldCount = fCount; 114 if (count) 115 { 116 SkASSERT(src == NULL || fArray == NULL || 117 src + count <= fArray || fArray + count <= src); 118 119 this->growBy(count); 120 if (src) 121 memcpy(fArray + oldCount, src, sizeof(int32_t) * count); 122 } 123 return fArray + oldCount; 124 } 125 126 int SkDS32Array::find(const int32_t& elem) const 127 { 128 const int32_t* iter = fArray; 129 const int32_t* stop = fArray + fCount; 130 131 for (; iter < stop; iter++) 132 { 133 if (*iter == elem) 134 return (int) (iter - fArray); 135 } 136 return -1; 137 } 138 139 void SkDS32Array::growBy(U16CPU extra) 140 { 141 SkASSERT(extra); 142 SkASSERT(fCount + extra <= 0xFFFF); 143 144 if (fCount + extra > fReserve) 145 { 146 size_t size = fCount + extra + 4; 147 size += size >> 2; 148 int32_t* array = (int32_t*)sk_malloc_throw(size * sizeof(int32_t)); 149 memcpy(array, fArray, fCount * sizeof(int32_t)); 150 151 sk_free(fArray); 152 fArray = array; 153 #ifdef SK_DEBUG 154 fData = (int32_t (*)[kDebugArraySize]) fArray; 155 #endif 156 fReserve = SkToU16((U16CPU)size); 157 } 158 fCount = SkToU16(fCount + extra); 159 } 160 161 int32_t* SkDS32Array::insert(U16CPU index, U16CPU count, const int32_t* src) 162 { 163 SkASSERT(count); 164 int oldCount = fCount; 165 this->growBy(count); 166 int32_t* dst = fArray + index; 167 memmove(dst + count, dst, sizeof(int32_t) * (oldCount - index)); 168 if (src) 169 memcpy(dst, src, sizeof(int32_t) * count); 170 return dst; 171 } 172 173 174 int SkDS32Array::rfind(const int32_t& elem) const 175 { 176 const int32_t* iter = fArray + fCount; 177 const int32_t* stop = fArray; 178 179 while (iter > stop) 180 { 181 if (*--iter == elem) 182 return (int) (iter - stop); 183 } 184 return -1; 185 } 186 187 #endif 188