Home | History | Annotate | Download | only in animator 
      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