LCOV - code coverage report
Current view: directory - gfx/skia/src/core - SkMetaData.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 192 0 0.0 %
Date: 2012-06-02 Functions: 34 0 0.0 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       4                 :  *
       5                 :  * Use of this source code is governed by a BSD-style license that can be
       6                 :  * found in the LICENSE file.
       7                 :  */
       8                 : 
       9                 : 
      10                 : #include "SkMetaData.h"
      11                 : #include "SkRefCnt.h"
      12                 : 
      13                 : struct PtrPair {
      14                 :     void*               fPtr;
      15                 :     SkMetaData::PtrProc fProc;
      16                 : };
      17                 : 
      18               0 : void* SkMetaData::RefCntProc(void* ptr, bool doRef) {
      19               0 :     SkASSERT(ptr);
      20               0 :     SkRefCnt* refcnt = reinterpret_cast<SkRefCnt*>(ptr);
      21                 : 
      22               0 :     if (doRef) {
      23               0 :         refcnt->ref();
      24                 :     } else {
      25               0 :         refcnt->unref();
      26                 :     }
      27               0 :     return ptr;
      28                 : }
      29                 : 
      30               0 : SkMetaData::SkMetaData() : fRec(NULL)
      31                 : {
      32               0 : }
      33                 : 
      34               0 : SkMetaData::SkMetaData(const SkMetaData& src) : fRec(NULL)
      35                 : {
      36               0 :     *this = src;
      37               0 : }
      38                 : 
      39               0 : SkMetaData::~SkMetaData()
      40                 : {
      41               0 :     this->reset();
      42               0 : }
      43                 : 
      44               0 : void SkMetaData::reset()
      45                 : {
      46               0 :     Rec* rec = fRec;
      47               0 :     while (rec) {
      48               0 :         if (kPtr_Type == rec->fType) {
      49               0 :             PtrPair* pair = (PtrPair*)rec->data();
      50               0 :             if (pair->fProc && pair->fPtr) {
      51               0 :                 pair->fPtr = pair->fProc(pair->fPtr, false);
      52                 :             }
      53                 :         }
      54               0 :         Rec* next = rec->fNext;
      55               0 :         Rec::Free(rec);
      56               0 :         rec = next;
      57                 :     }
      58               0 :     fRec = NULL;
      59               0 : }
      60                 : 
      61               0 : SkMetaData& SkMetaData::operator=(const SkMetaData& src)
      62                 : {
      63               0 :     this->reset();
      64                 : 
      65               0 :     const Rec* rec = src.fRec;
      66               0 :     while (rec)
      67                 :     {
      68               0 :         this->set(rec->name(), rec->data(), rec->fDataLen, (Type)rec->fType, rec->fDataCount);
      69               0 :         rec = rec->fNext;
      70                 :     }
      71               0 :     return *this;
      72                 : }
      73                 : 
      74               0 : void SkMetaData::setS32(const char name[], int32_t value)
      75                 : {
      76               0 :     (void)this->set(name, &value, sizeof(int32_t), kS32_Type, 1);
      77               0 : }
      78                 : 
      79               0 : void SkMetaData::setScalar(const char name[], SkScalar value)
      80                 : {
      81               0 :     (void)this->set(name, &value, sizeof(SkScalar), kScalar_Type, 1);
      82               0 : }
      83                 : 
      84               0 : SkScalar* SkMetaData::setScalars(const char name[], int count, const SkScalar values[])
      85                 : {
      86               0 :     SkASSERT(count > 0);
      87               0 :     if (count > 0)
      88               0 :         return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
      89               0 :     return NULL;
      90                 : }
      91                 : 
      92               0 : void SkMetaData::setString(const char name[], const char value[])
      93                 : {
      94               0 :     (void)this->set(name, value, sizeof(char), kString_Type, strlen(value) + 1);
      95               0 : }
      96                 : 
      97               0 : void SkMetaData::setPtr(const char name[], void* ptr, PtrProc proc) {
      98               0 :     PtrPair pair = { ptr, proc };
      99               0 :     (void)this->set(name, &pair, sizeof(PtrPair), kPtr_Type, 1);
     100               0 : }
     101                 : 
     102               0 : void SkMetaData::setBool(const char name[], bool value)
     103                 : {
     104               0 :     (void)this->set(name, &value, sizeof(bool), kBool_Type, 1);
     105               0 : }
     106                 : 
     107               0 : void SkMetaData::setData(const char name[], const void* data, size_t byteCount) {
     108               0 :     (void)this->set(name, data, sizeof(char), kData_Type, byteCount);
     109               0 : }
     110                 : 
     111               0 : void* SkMetaData::set(const char name[], const void* data, size_t dataSize, Type type, int count)
     112                 : {
     113               0 :     SkASSERT(name);
     114               0 :     SkASSERT(dataSize);
     115               0 :     SkASSERT(count > 0);
     116                 : 
     117               0 :     (void)this->remove(name, type);
     118                 : 
     119               0 :     size_t  len = strlen(name);
     120               0 :     Rec*    rec = Rec::Alloc(sizeof(Rec) + dataSize * count + len + 1);
     121                 : 
     122                 : #ifndef SK_DEBUG
     123                 :     rec->fType = SkToU8(type);
     124                 : #else
     125               0 :     rec->fType = type;
     126                 : #endif
     127               0 :     rec->fDataLen = SkToU8(dataSize);
     128               0 :     rec->fDataCount = SkToU16(count);
     129               0 :     if (data)
     130               0 :         memcpy(rec->data(), data, dataSize * count);
     131               0 :     memcpy(rec->name(), name, len + 1);
     132                 : 
     133               0 :     if (kPtr_Type == type) {
     134               0 :         PtrPair* pair = (PtrPair*)rec->data();
     135               0 :         if (pair->fProc && pair->fPtr) {
     136               0 :             pair->fPtr = pair->fProc(pair->fPtr, true);
     137                 :         }
     138                 :     }
     139                 : 
     140               0 :     rec->fNext = fRec;
     141               0 :     fRec = rec;
     142               0 :     return rec->data();
     143                 : }
     144                 : 
     145               0 : bool SkMetaData::findS32(const char name[], int32_t* value) const
     146                 : {
     147               0 :     const Rec* rec = this->find(name, kS32_Type);
     148               0 :     if (rec)
     149                 :     {
     150               0 :         SkASSERT(rec->fDataCount == 1);
     151               0 :         if (value)
     152               0 :             *value = *(const int32_t*)rec->data();
     153               0 :         return true;
     154                 :     }
     155               0 :     return false;
     156                 : }
     157                 : 
     158               0 : bool SkMetaData::findScalar(const char name[], SkScalar* value) const
     159                 : {
     160               0 :     const Rec* rec = this->find(name, kScalar_Type);
     161               0 :     if (rec)
     162                 :     {
     163               0 :         SkASSERT(rec->fDataCount == 1);
     164               0 :         if (value)
     165               0 :             *value = *(const SkScalar*)rec->data();
     166               0 :         return true;
     167                 :     }
     168               0 :     return false;
     169                 : }
     170                 : 
     171               0 : const SkScalar* SkMetaData::findScalars(const char name[], int* count, SkScalar values[]) const
     172                 : {
     173               0 :     const Rec* rec = this->find(name, kScalar_Type);
     174               0 :     if (rec)
     175                 :     {
     176               0 :         if (count)
     177               0 :             *count = rec->fDataCount;
     178               0 :         if (values)
     179               0 :             memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
     180               0 :         return (const SkScalar*)rec->data();
     181                 :     }
     182               0 :     return NULL;
     183                 : }
     184                 : 
     185               0 : bool SkMetaData::findPtr(const char name[], void** ptr, PtrProc* proc) const {
     186               0 :     const Rec* rec = this->find(name, kPtr_Type);
     187               0 :     if (rec) {
     188               0 :         SkASSERT(rec->fDataCount == 1);
     189               0 :         const PtrPair* pair = (const PtrPair*)rec->data();
     190               0 :         if (ptr) {
     191               0 :             *ptr = pair->fPtr;
     192                 :         }
     193               0 :         if (proc) {
     194               0 :             *proc = pair->fProc;
     195                 :         }
     196               0 :         return true;
     197                 :     }
     198               0 :     return false;
     199                 : }
     200                 : 
     201               0 : const char* SkMetaData::findString(const char name[]) const
     202                 : {
     203               0 :     const Rec* rec = this->find(name, kString_Type);
     204               0 :     SkASSERT(rec == NULL || rec->fDataLen == sizeof(char));
     205               0 :     return rec ? (const char*)rec->data() : NULL;
     206                 : }
     207                 : 
     208               0 : bool SkMetaData::findBool(const char name[], bool* value) const
     209                 : {
     210               0 :     const Rec* rec = this->find(name, kBool_Type);
     211               0 :     if (rec)
     212                 :     {
     213               0 :         SkASSERT(rec->fDataCount == 1);
     214               0 :         if (value)
     215               0 :             *value = *(const bool*)rec->data();
     216               0 :         return true;
     217                 :     }
     218               0 :     return false;
     219                 : }
     220                 : 
     221               0 : const void* SkMetaData::findData(const char name[], size_t* length) const {
     222               0 :     const Rec* rec = this->find(name, kData_Type);
     223               0 :     if (rec) {
     224               0 :         SkASSERT(rec->fDataLen == sizeof(char));
     225               0 :         if (length) {
     226               0 :             *length = rec->fDataCount;
     227                 :         }
     228               0 :         return rec->data();
     229                 :     }
     230               0 :     return NULL;
     231                 : }
     232                 : 
     233               0 : const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const
     234                 : {
     235               0 :     const Rec* rec = fRec;
     236               0 :     while (rec)
     237                 :     {
     238               0 :         if (rec->fType == type && !strcmp(rec->name(), name))
     239               0 :             return rec;
     240               0 :         rec = rec->fNext;
     241                 :     }
     242               0 :     return NULL;
     243                 : }
     244                 : 
     245               0 : bool SkMetaData::remove(const char name[], Type type) {
     246               0 :     Rec* rec = fRec;
     247               0 :     Rec* prev = NULL;
     248               0 :     while (rec) {
     249               0 :         Rec* next = rec->fNext;
     250               0 :         if (rec->fType == type && !strcmp(rec->name(), name)) {
     251               0 :             if (prev) {
     252               0 :                 prev->fNext = next;
     253                 :             } else {
     254               0 :                 fRec = next;
     255                 :             }
     256                 : 
     257               0 :             if (kPtr_Type == type) {
     258               0 :                 PtrPair* pair = (PtrPair*)rec->data();
     259               0 :                 if (pair->fProc && pair->fPtr) {
     260               0 :                     (void)pair->fProc(pair->fPtr, false);
     261                 :                 }
     262                 :             }
     263               0 :             Rec::Free(rec);
     264               0 :             return true;
     265                 :         }
     266               0 :         prev = rec;
     267               0 :         rec = next;
     268                 :     }
     269               0 :     return false;
     270                 : }
     271                 : 
     272               0 : bool SkMetaData::removeS32(const char name[])
     273                 : {
     274               0 :     return this->remove(name, kS32_Type);
     275                 : }
     276                 : 
     277               0 : bool SkMetaData::removeScalar(const char name[])
     278                 : {
     279               0 :     return this->remove(name, kScalar_Type);
     280                 : }
     281                 : 
     282               0 : bool SkMetaData::removeString(const char name[])
     283                 : {
     284               0 :     return this->remove(name, kString_Type);
     285                 : }
     286                 : 
     287               0 : bool SkMetaData::removePtr(const char name[])
     288                 : {
     289               0 :     return this->remove(name, kPtr_Type);
     290                 : }
     291                 : 
     292               0 : bool SkMetaData::removeBool(const char name[])
     293                 : {
     294               0 :     return this->remove(name, kBool_Type);
     295                 : }
     296                 : 
     297               0 : bool SkMetaData::removeData(const char name[]) {
     298               0 :     return this->remove(name, kData_Type);
     299                 : }
     300                 : 
     301                 : ///////////////////////////////////////////////////////////////////////////////
     302                 : 
     303               0 : SkMetaData::Iter::Iter(const SkMetaData& metadata) {
     304               0 :     fRec = metadata.fRec;
     305               0 : }
     306                 : 
     307               0 : void SkMetaData::Iter::reset(const SkMetaData& metadata) {
     308               0 :     fRec = metadata.fRec;
     309               0 : }
     310                 : 
     311               0 : const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count) {
     312               0 :     const char* name = NULL;
     313                 : 
     314               0 :     if (fRec) {
     315               0 :         if (t) {
     316               0 :             *t = (SkMetaData::Type)fRec->fType;
     317                 :         }
     318               0 :         if (count) {
     319               0 :             *count = fRec->fDataCount;
     320                 :         }
     321               0 :         name = fRec->name();
     322                 : 
     323               0 :         fRec = fRec->fNext;
     324                 :     }
     325               0 :     return name;
     326                 : }
     327                 : 
     328                 : ///////////////////////////////////////////////////////////////////////////////
     329                 : 
     330               0 : SkMetaData::Rec* SkMetaData::Rec::Alloc(size_t size) {
     331               0 :     return (Rec*)sk_malloc_throw(size);
     332                 : }
     333                 : 
     334               0 : void SkMetaData::Rec::Free(Rec* rec) {
     335               0 :     sk_free(rec);
     336               0 : }
     337                 : 

Generated by: LCOV version 1.7