LCOV - app.info - gfx/skia/src/core/SkDeque.cpp

LCOV - code coverage report
| Current view: | directory - gfx/skia/src/core - SkDeque.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 146 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 15 | 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 "SkDeque.h"
          11                 :
          12                 : #define INIT_ELEM_COUNT 1  // should we let the caller set this?
          13                 :
          14                 : struct SkDeque::Head {
          15                 :     Head*   fNext;
          16                 :     Head*   fPrev;
          17                 :     char*   fBegin; // start of used section in this chunk
          18                 :     char*   fEnd;   // end of used section in this chunk
          19                 :     char*   fStop;  // end of the allocated chunk
          20                 :
          21               0 :     char*       start() { return (char*)(this + 1); }
          22                 :     const char* start() const { return (const char*)(this + 1); }
          23                 :
          24               0 :     void init(size_t size) {
          25               0 :         fNext   = fPrev = NULL;
          26               0 :         fBegin  = fEnd = NULL;
          27               0 :         fStop   = (char*)this + size;
          28               0 :     }
          29                 : };
          30                 :
          31               0 : SkDeque::SkDeque(size_t elemSize)
          32               0 :         : fElemSize(elemSize), fInitialStorage(NULL), fCount(0) {
          33               0 :     fFront = fBack = NULL;
          34               0 : }
          35                 :
          36               0 : SkDeque::SkDeque(size_t elemSize, void* storage, size_t storageSize)
          37               0 :         : fElemSize(elemSize), fInitialStorage(storage), fCount(0) {
          38               0 :     SkASSERT(storageSize == 0 || storage != NULL);
          39                 :
          40               0 :     if (storageSize >= sizeof(Head) + elemSize) {
          41               0 :         fFront = (Head*)storage;
          42               0 :         fFront->init(storageSize);
          43                 :     } else {
          44               0 :         fFront = NULL;
          45                 :     }
          46               0 :     fBack = fFront;
          47               0 : }
          48                 :
          49               0 : SkDeque::~SkDeque() {
          50               0 :     Head* head = fFront;
          51               0 :     Head* initialHead = (Head*)fInitialStorage;
          52                 :
          53               0 :     while (head) {
          54               0 :         Head* next = head->fNext;
          55               0 :         if (head != initialHead) {
          56               0 :             sk_free(head);
          57                 :         }
          58               0 :         head = next;
          59                 :     }
          60               0 : }
          61                 :
          62               0 : const void* SkDeque::front() const {
          63               0 :     Head* front = fFront;
          64                 :
          65               0 :     if (NULL == front) {
          66               0 :         return NULL;
          67                 :     }
          68               0 :     if (NULL == front->fBegin) {
          69               0 :         front = front->fNext;
          70               0 :         if (NULL == front) {
          71               0 :             return NULL;
          72                 :         }
          73                 :     }
          74               0 :     SkASSERT(front->fBegin);
          75               0 :     return front->fBegin;
          76                 : }
          77                 :
          78               0 : const void* SkDeque::back() const {
          79               0 :     Head* back = fBack;
          80                 :
          81               0 :     if (NULL == back) {
          82               0 :         return NULL;
          83                 :     }
          84               0 :     if (NULL == back->fEnd) {  // marked as deleted
          85               0 :         back = back->fPrev;
          86               0 :         if (NULL == back) {
          87               0 :             return NULL;
          88                 :         }
          89                 :     }
          90               0 :     SkASSERT(back->fEnd);
          91               0 :     return back->fEnd - fElemSize;
          92                 : }
          93                 :
          94               0 : void* SkDeque::push_front() {
          95               0 :     fCount += 1;
          96                 :
          97               0 :     if (NULL == fFront) {
          98                 :         fFront = (Head*)sk_malloc_throw(sizeof(Head) +
          99               0 :                                         INIT_ELEM_COUNT * fElemSize);
         100               0 :         fFront->init(sizeof(Head) + INIT_ELEM_COUNT * fElemSize);
         101               0 :         fBack = fFront;     // update our linklist
         102                 :     }
         103                 :
         104               0 :     Head*   first = fFront;
         105                 :     char*   begin;
         106                 :
         107               0 :     if (NULL == first->fBegin) {
         108                 :     INIT_CHUNK:
         109               0 :         first->fEnd = first->fStop;
         110               0 :         begin = first->fStop - fElemSize;
         111                 :     } else {
         112               0 :         begin = first->fBegin - fElemSize;
         113               0 :         if (begin < first->start()) {    // no more room in this chunk
         114                 :             // should we alloc more as we accumulate more elements?
         115               0 :             size_t  size = sizeof(Head) + INIT_ELEM_COUNT * fElemSize;
         116                 :
         117               0 :             first = (Head*)sk_malloc_throw(size);
         118               0 :             first->init(size);
         119               0 :             first->fNext = fFront;
         120               0 :             fFront->fPrev = first;
         121               0 :             fFront = first;
         122               0 :             goto INIT_CHUNK;
         123                 :         }
         124                 :     }
         125                 :
         126               0 :     first->fBegin = begin;
         127               0 :     return begin;
         128                 : }
         129                 :
         130               0 : void* SkDeque::push_back() {
         131               0 :     fCount += 1;
         132                 :
         133               0 :     if (NULL == fBack) {
         134                 :         fBack = (Head*)sk_malloc_throw(sizeof(Head) +
         135               0 :                                        INIT_ELEM_COUNT * fElemSize);
         136               0 :         fBack->init(sizeof(Head) + INIT_ELEM_COUNT * fElemSize);
         137               0 :         fFront = fBack; // update our linklist
         138                 :     }
         139                 :
         140               0 :     Head*   last = fBack;
         141                 :     char*   end;
         142                 :
         143               0 :     if (NULL == last->fBegin) {
         144                 :     INIT_CHUNK:
         145               0 :         last->fBegin = last->start();
         146               0 :         end = last->fBegin + fElemSize;
         147                 :     } else {
         148               0 :         end = last->fEnd + fElemSize;
         149               0 :         if (end > last->fStop) {  // no more room in this chunk
         150                 :             // should we alloc more as we accumulate more elements?
         151               0 :             size_t  size = sizeof(Head) + INIT_ELEM_COUNT * fElemSize;
         152                 :
         153               0 :             last = (Head*)sk_malloc_throw(size);
         154               0 :             last->init(size);
         155               0 :             last->fPrev = fBack;
         156               0 :             fBack->fNext = last;
         157               0 :             fBack = last;
         158               0 :             goto INIT_CHUNK;
         159                 :         }
         160                 :     }
         161                 :
         162               0 :     last->fEnd = end;
         163               0 :     return end - fElemSize;
         164                 : }
         165                 :
         166               0 : void SkDeque::pop_front() {
         167               0 :     SkASSERT(fCount > 0);
         168               0 :     fCount -= 1;
         169                 :
         170               0 :     Head*   first = fFront;
         171                 :
         172               0 :     SkASSERT(first != NULL);
         173                 :
         174               0 :     if (first->fBegin == NULL) {  // we were marked empty from before
         175               0 :         first = first->fNext;
         176               0 :         first->fPrev = NULL;
         177               0 :         sk_free(fFront);
         178               0 :         fFront = first;
         179               0 :         SkASSERT(first != NULL);    // else we popped too far
         180                 :     }
         181                 :
         182               0 :     char* begin = first->fBegin + fElemSize;
         183               0 :     SkASSERT(begin <= first->fEnd);
         184                 :
         185               0 :     if (begin < fFront->fEnd) {
         186               0 :         first->fBegin = begin;
         187                 :     } else {
         188               0 :         first->fBegin = first->fEnd = NULL;  // mark as empty
         189                 :     }
         190               0 : }
         191                 :
         192               0 : void SkDeque::pop_back() {
         193               0 :     SkASSERT(fCount > 0);
         194               0 :     fCount -= 1;
         195                 :
         196               0 :     Head* last = fBack;
         197                 :
         198               0 :     SkASSERT(last != NULL);
         199                 :
         200               0 :     if (last->fEnd == NULL) {  // we were marked empty from before
         201               0 :         last = last->fPrev;
         202               0 :         last->fNext = NULL;
         203               0 :         sk_free(fBack);
         204               0 :         fBack = last;
         205               0 :         SkASSERT(last != NULL);  // else we popped too far
         206                 :     }
         207                 :
         208               0 :     char* end = last->fEnd - fElemSize;
         209               0 :     SkASSERT(end >= last->fBegin);
         210                 :
         211               0 :     if (end > last->fBegin) {
         212               0 :         last->fEnd = end;
         213                 :     } else {
         214               0 :         last->fBegin = last->fEnd = NULL;    // mark as empty
         215                 :     }
         216               0 : }
         217                 :
         218                 : ///////////////////////////////////////////////////////////////////////////////
         219                 :
         220               0 : SkDeque::F2BIter::F2BIter() : fHead(NULL), fPos(NULL), fElemSize(0) {}
         221                 :
         222               0 : SkDeque::F2BIter::F2BIter(const SkDeque& d) {
         223               0 :     this->reset(d);
         224               0 : }
         225                 :
         226               0 : void* SkDeque::F2BIter::next() {
         227               0 :     char* pos = fPos;
         228                 :
         229               0 :     if (pos) {   // if we were valid, try to move to the next setting
         230               0 :         char* next = pos + fElemSize;
         231               0 :         SkASSERT(next <= fHead->fEnd);
         232               0 :         if (next == fHead->fEnd) { // exhausted this chunk, move to next
         233               0 :             do {
         234               0 :                 fHead = fHead->fNext;
         235                 :             } while (fHead != NULL && fHead->fBegin == NULL);
         236               0 :             next = fHead ? fHead->fBegin : NULL;
         237                 :         }
         238               0 :         fPos = next;
         239                 :     }
         240               0 :     return pos;
         241                 : }
         242                 :
         243               0 : void SkDeque::F2BIter::reset(const SkDeque& d) {
         244               0 :     fElemSize = d.fElemSize;
         245               0 :     fHead = d.fFront;
         246               0 :     while (fHead != NULL && fHead->fBegin == NULL) {
         247               0 :         fHead = fHead->fNext;
         248                 :     }
         249               0 :     fPos = fHead ? fHead->fBegin : NULL;
         250               0 : }

Generated by: LCOV version 1.7