LCOV - app.info - xpcom/glue/nsDeque.cpp

LCOV - code coverage report
| Current view: | directory - xpcom/glue - nsDeque.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 169 | 92 | 54.4 %
| Date: | 2012-06-02 | Functions: | 34 | 13 | 38.2 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : #include "nsDeque.h"
          39                 : #include "nsCRT.h"
          40                 : #ifdef DEBUG_rickg
          41                 : #include <stdio.h>
          42                 : #endif
          43                 :
          44                 : /**
          45                 :  * 07/02/2001  09:17p 509,104 clangref.pdf from openwatcom's site
          46                 :  * Watcom C Language Reference Edition 11.0c
          47                 :  * page 118 of 297
          48                 :  *
          49                 :  * The % symbol yields the remainder from the division of the first operand
          50                 :  * by the second operand. The operands of % must have integral type.
          51                 :  *
          52                 :  * When both operands of % are positive, the result is a positive value
          53                 :  * smaller than the second operand. When one or both operands is negative,
          54                 :  * whether the result is positive or negative is implementation-defined.
          55                 :  *
          56                 :  */
          57                 : /* Ok, so first of all, C is underspecified. joy.
          58                 :  * The following functions do not provide a correct implementation of modulus
          59                 :  * They provide functionality for x>-y.
          60                 :  * There are risks of 2*y being greater than max int, which is part of the
          61                 :  * reason no multiplication is used and other operations are avoided.
          62                 :  *
          63                 :  * modasgn
          64                 :  * @param x variable
          65                 :  * @param y expression
          66                 :  * approximately equivalent to x %= y
          67                 :  *
          68                 :  * modulus
          69                 :  * @param x expression
          70                 :  * @param y expression
          71                 :  * approximately equivalent to x % y
          72                 :  */
          73                 : #define modasgn(x,y) if (x<0) x+=y; x%=y
          74                 : #define modulus(x,y) ((x<0)?(x+y)%(y):(x)%(y))
          75                 :
          76                 : /**
          77                 :  * Standard constructor
          78                 :  * @param deallocator, called by Erase and ~nsDeque
          79                 :  */
          80               5 : nsDeque::nsDeque(nsDequeFunctor* aDeallocator) {
          81               5 :   MOZ_COUNT_CTOR(nsDeque);
          82               5 :   mDeallocator=aDeallocator;
          83               5 :   mOrigin=mSize=0;
          84               5 :   mData=mBuffer; // don't allocate space until you must
          85               5 :   mCapacity=sizeof(mBuffer)/sizeof(mBuffer[0]);
          86               5 :   memset(mData, 0, mCapacity*sizeof(mBuffer[0]));
          87               5 : }
          88                 :
          89                 : /**
          90                 :  * Destructor
          91                 :  */
          92               5 : nsDeque::~nsDeque() {
          93               5 :   MOZ_COUNT_DTOR(nsDeque);
          94                 :
          95                 : #ifdef DEBUG_rickg
          96                 :   char buffer[30];
          97                 :   printf("Capacity: %i\n", mCapacity);
          98                 :
          99                 :   static int mCaps[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
         100                 :   switch(mCapacity) {
         101                 :     case 4:     mCaps[0]++; break;
         102                 :     case 8:     mCaps[1]++; break;
         103                 :     case 16:    mCaps[2]++; break;
         104                 :     case 32:    mCaps[3]++; break;
         105                 :     case 64:    mCaps[4]++; break;
         106                 :     case 128:   mCaps[5]++; break;
         107                 :     case 256:   mCaps[6]++; break;
         108                 :     case 512:   mCaps[7]++; break;
         109                 :     case 1024:  mCaps[8]++; break;
         110                 :     case 2048:  mCaps[9]++; break;
         111                 :     case 4096:  mCaps[10]++; break;
         112                 :     default:
         113                 :       break;
         114                 :   }
         115                 : #endif
         116                 :
         117               5 :   Erase();
         118               5 :   if (mData && (mData!=mBuffer)) {
         119               1 :     free(mData);
         120                 :   }
         121               5 :   mData=0;
         122               5 :   SetDeallocator(0);
         123               5 : }
         124                 :
         125                 : /**
         126                 :  * Set the functor to be called by Erase()
         127                 :  * The deque owns the functor.
         128                 :  *
         129                 :  * @param   aDeallocator functor object for use by Erase()
         130                 :  */
         131               5 : void nsDeque::SetDeallocator(nsDequeFunctor* aDeallocator){
         132               5 :   delete mDeallocator;
         133               5 :   mDeallocator=aDeallocator;
         134               5 : }
         135                 :
         136                 : /**
         137                 :  * Remove all items from container without destroying them.
         138                 :  *
         139                 :  * @return  *this
         140                 :  */
         141               5 : nsDeque& nsDeque::Empty() {
         142               5 :   if (mSize && mData) {
         143               1 :     memset(mData, 0, mCapacity*sizeof(mData));
         144                 :   }
         145               5 :   mSize=0;
         146               5 :   mOrigin=0;
         147               5 :   return *this;
         148                 : }
         149                 :
         150                 : /**
         151                 :  * Remove and delete all items from container
         152                 :  *
         153                 :  * @return  *this
         154                 :  */
         155               5 : nsDeque& nsDeque::Erase() {
         156               5 :   if (mDeallocator && mSize) {
         157               0 :     ForEach(*mDeallocator);
         158                 :   }
         159               5 :   return Empty();
         160                 : }
         161                 :
         162                 : /**
         163                 :  * This method quadruples the size of the deque
         164                 :  * Elements in the deque are resequenced so that elements
         165                 :  * in the deque are stored sequentially
         166                 :  *
         167                 :  * If the deque actually overflows, there's very little we can do.
         168                 :  * Perhaps this function should return bool/nsresult indicating success/failure.
         169                 :  *
         170                 :  * @return  whether growing succeeded
         171                 :  */
         172               2 : bool nsDeque::GrowCapacity() {
         173               2 :   PRInt32 theNewSize=mCapacity<<2;
         174               2 :   NS_ASSERTION(theNewSize>mCapacity, "Overflow");
         175               2 :   if (theNewSize<=mCapacity)
         176               0 :     return false;
         177               2 :   void** temp=(void**)malloc(theNewSize * sizeof(void*));
         178               2 :   if (!temp)
         179               0 :     return false;
         180                 :
         181                 :   //Here's the interesting part: You can't just move the elements
         182                 :   //directly (in situ) from the old buffer to the new one.
         183                 :   //Since capacity has changed, the old origin doesn't make
         184                 :   //sense anymore. It's better to resequence the elements now.
         185                 :
         186               2 :   memcpy(temp, mData + mOrigin, sizeof(void*) * (mCapacity - mOrigin));
         187               2 :   memcpy(temp + (mCapacity - mOrigin), mData, sizeof(void*) * mOrigin);
         188                 :
         189               2 :   if (mData != mBuffer) {
         190               1 :     free(mData);
         191                 :   }
         192                 :
         193               2 :   mCapacity=theNewSize;
         194               2 :   mOrigin=0; //now realign the origin...
         195               2 :   mData=temp;
         196                 :
         197               2 :   return true;
         198                 : }
         199                 :
         200                 : /**
         201                 :  * This method adds an item to the end of the deque.
         202                 :  * This operation has the potential to cause the
         203                 :  * underlying buffer to resize.
         204                 :  *
         205                 :  * @param   aItem: new item to be added to deque
         206                 :  * @return  *this
         207                 :  */
         208             176 : nsDeque& nsDeque::Push(void* aItem) {
         209             176 :   if (mSize==mCapacity && !GrowCapacity()) {
         210               0 :     NS_WARNING("out of memory");
         211               0 :     return *this;
         212                 :   }
         213             176 :   mData[modulus(mOrigin + mSize, mCapacity)]=aItem;
         214             176 :   mSize++;
         215             176 :   return *this;
         216                 : }
         217                 :
         218                 : /**
         219                 :  * This method adds an item to the front of the deque.
         220                 :  * This operation has the potential to cause the
         221                 :  * underlying buffer to resize.
         222                 :  *
         223                 :  * --Commments for GrowCapacity() case
         224                 :  * We've grown and shifted which means that the old
         225                 :  * final element in the deque is now the first element
         226                 :  * in the deque.  This is temporary.
         227                 :  * We haven't inserted the new element at the front.
         228                 :  *
         229                 :  * To continue with the idea of having the front at zero
         230                 :  * after a grow, we move the old final item (which through
         231                 :  * the voodoo of mOrigin-- is now the first) to its final
         232                 :  * position which is conveniently the old length.
         233                 :  *
         234                 :  * Note that this case only happens when the deque is full.
         235                 :  * [And that pieces of this magic only work if the deque is full.]
         236                 :  * picture:
         237                 :  *   [ABCDEFGH] @[mOrigin:3]:D.
         238                 :  * Task: PushFront("Z")
         239                 :  * shift mOrigin so, @[mOrigin:2]:C
         240                 :  * stretch and rearrange: (mOrigin:0)
         241                 :  *   [CDEFGHAB ________ ________ ________]
         242                 :  * copy: (The second C is currently out of bounds)
         243                 :  *   [CDEFGHAB C_______ ________ ________]
         244                 :  * later we will insert Z:
         245                 :  *   [ZDEFGHAB C_______ ________ ________]
         246                 :  * and increment size: 9. (C is no longer out of bounds)
         247                 :  * --
         248                 :  * @param   aItem: new item to be added to deque
         249                 :  * @return  *this
         250                 :  */
         251               4 : nsDeque& nsDeque::PushFront(void* aItem) {
         252               4 :   mOrigin--;
         253               4 :   modasgn(mOrigin,mCapacity);
         254               4 :   if (mSize==mCapacity) {
         255               0 :     if (!GrowCapacity()) {
         256               0 :       NS_WARNING("out of memory");
         257               0 :       return *this;
         258                 :     }
         259                 :     /* Comments explaining this are above*/
         260               0 :     mData[mSize]=mData[mOrigin];
         261                 :   }
         262               4 :   mData[mOrigin]=aItem;
         263               4 :   mSize++;
         264               4 :   return *this;
         265                 : }
         266                 :
         267                 : /**
         268                 :  * Remove and return the last item in the container.
         269                 :  *
         270                 :  * @return  ptr to last item in container
         271                 :  */
         272             160 : void* nsDeque::Pop() {
         273             160 :   void* result=0;
         274             160 :   if (mSize>0) {
         275             160 :     --mSize;
         276             160 :     PRInt32 offset=modulus(mSize + mOrigin, mCapacity);
         277             160 :     result=mData[offset];
         278             160 :     mData[offset]=0;
         279             160 :     if (!mSize) {
         280               1 :       mOrigin=0;
         281                 :     }
         282                 :   }
         283             160 :   return result;
         284                 : }
         285                 :
         286                 : /**
         287                 :  * This method gets called you want to remove and return
         288                 :  * the first member in the container.
         289                 :  *
         290                 :  * @return  last item in container
         291                 :  */
         292              12 : void* nsDeque::PopFront() {
         293              12 :   void* result=0;
         294              12 :   if (mSize>0) {
         295              12 :     NS_ASSERTION(mOrigin < mCapacity, "Error: Bad origin");
         296              12 :     result=mData[mOrigin];
         297              12 :     mData[mOrigin++]=0;     //zero it out for debugging purposes.
         298              12 :     mSize--;
         299                 :     // Cycle around if we pop off the end
         300                 :     // and reset origin if when we pop the last element
         301              12 :     if (mCapacity==mOrigin || !mSize) {
         302               2 :       mOrigin=0;
         303                 :     }
         304                 :   }
         305              12 :   return result;
         306                 : }
         307                 :
         308                 : /**
         309                 :  * This method gets called you want to peek at the bottom
         310                 :  * member without removing it.
         311                 :  *
         312                 :  * @return  last item in container
         313                 :  */
         314             166 : void* nsDeque::Peek() {
         315             166 :   void* result=0;
         316             166 :   if (mSize>0) {
         317             166 :     result = mData[modulus(mSize - 1 + mOrigin, mCapacity)];
         318                 :   }
         319             166 :   return result;
         320                 : }
         321                 :
         322                 : /**
         323                 :  * This method gets called you want to peek at the topmost
         324                 :  * member without removing it.
         325                 :  *
         326                 :  * @return  last item in container
         327                 :  */
         328               0 : void* nsDeque::PeekFront() {
         329               0 :   void* result=0;
         330               0 :   if (mSize>0) {
         331               0 :     result=mData[mOrigin];
         332                 :   }
         333               0 :   return result;
         334                 : }
         335                 :
         336                 : /**
         337                 :  * Call this to retrieve the ith element from this container.
         338                 :  * Keep in mind that accessing the underlying elements is
         339                 :  * done in a relative fashion. Object 0 is not necessarily
         340                 :  * the first element (the first element is at mOrigin).
         341                 :  *
         342                 :  * @param   aIndex : 0 relative offset of item you want
         343                 :  * @return  void* or null
         344                 :  */
         345              29 : void* nsDeque::ObjectAt(PRInt32 aIndex) const {
         346              29 :   void* result=0;
         347              29 :   if ((aIndex>=0) && (aIndex<mSize)) {
         348              29 :     result=mData[modulus(mOrigin + aIndex, mCapacity)];
         349                 :   }
         350              29 :   return result;
         351                 : }
         352                 :
         353               4 : void* nsDeque::RemoveObjectAt(PRInt32 aIndex) {
         354               4 :   if ((aIndex<0) || (aIndex>=mSize)) {
         355               0 :     return 0;
         356                 :   }
         357               4 :   void* result=mData[modulus(mOrigin + aIndex, mCapacity)];
         358                 :
         359                 :   // "Shuffle down" all elements in the array by 1, overwritting the element
         360                 :   // being removed.
         361              19 :   for (PRInt32 i=aIndex; i<mSize; i++) {
         362              15 :     mData[modulus(mOrigin + i, mCapacity)] = mData[modulus(mOrigin + i + 1, mCapacity)];
         363                 :   }
         364               4 :   mSize--;
         365                 :
         366               4 :   return result;
         367                 : }
         368                 :
         369                 : /**
         370                 :  * Create and return an iterator pointing to
         371                 :  * the beginning of the queue. Note that this
         372                 :  * takes the circular buffer semantics into account.
         373                 :  *
         374                 :  * @return  new deque iterator, init'ed to 1st item
         375                 :  */
         376               0 : nsDequeIterator nsDeque::Begin() const{
         377               0 :   return nsDequeIterator(*this, 0);
         378                 : }
         379                 :
         380                 : /**
         381                 :  * Create and return an iterator pointing to
         382                 :  * the last item in the deque.
         383                 :  * Note that this takes the circular buffer semantics
         384                 :  * into account.
         385                 :  *
         386                 :  * @return  new deque iterator, init'ed to the last item
         387                 :  */
         388               0 : nsDequeIterator nsDeque::End() const{
         389               0 :   return nsDequeIterator(*this, mSize - 1);
         390                 : }
         391                 :
         392               0 : void* nsDeque::Last() const {
         393               0 :   return End().GetCurrent();
         394                 : }
         395                 :
         396                 : /**
         397                 :  * Call this method when you want to iterate all the
         398                 :  * members of the container, passing a functor along
         399                 :  * to call your code.
         400                 :  *
         401                 :  * @param   aFunctor object to call for each member
         402                 :  * @return  *this
         403                 :  */
         404               0 : void nsDeque::ForEach(nsDequeFunctor& aFunctor) const{
         405               0 :   for (PRInt32 i=0; i<mSize; i++) {
         406               0 :     aFunctor(ObjectAt(i));
         407                 :   }
         408               0 : }
         409                 :
         410                 : /**
         411                 :  * Call this method when you want to iterate all the
         412                 :  * members of the container, calling the functor you
         413                 :  * passed with each member. This process will interrupt
         414                 :  * if your function returns non 0 to this method.
         415                 :  *
         416                 :  * @param   aFunctor object to call for each member
         417                 :  * @return  first nonzero result of aFunctor or 0.
         418                 :  */
         419               0 : const void* nsDeque::FirstThat(nsDequeFunctor& aFunctor) const{
         420               0 :   for (PRInt32 i=0; i<mSize; i++) {
         421               0 :     void* obj=aFunctor(ObjectAt(i));
         422               0 :     if (obj) {
         423               0 :       return obj;
         424                 :     }
         425                 :   }
         426               0 :   return 0;
         427                 : }
         428                 :
         429                 : /******************************************************
         430                 :  * Here comes the nsDequeIterator class...
         431                 :  ******************************************************/
         432                 :
         433                 : /**
         434                 :  * DequeIterator is an object that knows how to iterate (forward and backward)
         435                 :  * through a Deque. Normally, you don't need to do this, but there are some special
         436                 :  * cases where it is pretty handy, so here you go.
         437                 :  *
         438                 :  * This is a standard dequeiterator constructor
         439                 :  *
         440                 :  * @param   aQueue is the deque object to be iterated
         441                 :  * @param   aIndex is the starting position for your iteration
         442                 :  */
         443               0 : nsDequeIterator::nsDequeIterator(const nsDeque& aQueue, int aIndex)
         444                 : : mIndex(aIndex),
         445               0 :   mDeque(aQueue)
         446                 : {
         447               0 : }
         448                 :
         449                 : /**
         450                 :  * Create a copy of a DequeIterator
         451                 :  *
         452                 :  * @param   aCopy is another iterator to copy from
         453                 :  */
         454               0 : nsDequeIterator::nsDequeIterator(const nsDequeIterator& aCopy)
         455                 : : mIndex(aCopy.mIndex),
         456               0 :   mDeque(aCopy.mDeque)
         457                 : {
         458               0 : }
         459                 :
         460                 : /**
         461                 :  * Moves iterator to first element in deque
         462                 :  * @return  *this
         463                 :  */
         464               0 : nsDequeIterator& nsDequeIterator::First(){
         465               0 :   mIndex=0;
         466               0 :   return *this;
         467                 : }
         468                 :
         469                 : /**
         470                 :  * Standard assignment operator for dequeiterator
         471                 :  *
         472                 :  * @param   aCopy is an iterator to be copied from
         473                 :  * @return  *this
         474                 :  */
         475               0 : nsDequeIterator& nsDequeIterator::operator=(const nsDequeIterator& aCopy) {
         476               0 :   NS_ASSERTION(&mDeque==&aCopy.mDeque,"you can't change the deque that an interator is iterating over, sorry.");
         477               0 :   mIndex=aCopy.mIndex;
         478               0 :   return *this;
         479                 : }
         480                 :
         481                 : /**
         482                 :  * preform ! operation against to iterators to test for equivalence
         483                 :  * (or lack thereof)!
         484                 :  *
         485                 :  * @param   aIter is the object to be compared to
         486                 :  * @return  TRUE if NOT equal.
         487                 :  */
         488               0 : bool nsDequeIterator::operator!=(nsDequeIterator& aIter) {
         489               0 :   return bool(!this->operator==(aIter));
         490                 : }
         491                 :
         492                 : /**
         493                 :  * Compare two iterators for increasing order.
         494                 :  *
         495                 :  * @param   aIter is the other iterator to be compared to
         496                 :  * @return  TRUE if this object points to an element before
         497                 :  *          the element pointed to by aIter.
         498                 :  *          FALSE if this and aIter are not iterating over the same deque.
         499                 :  */
         500               0 : bool nsDequeIterator::operator<(nsDequeIterator& aIter) {
         501               0 :   return bool(((mIndex<aIter.mIndex) && (&mDeque==&aIter.mDeque)));
         502                 : }
         503                 :
         504                 : /**
         505                 :  * Compare two iterators for equivalence.
         506                 :  *
         507                 :  * @param   aIter is the other iterator to be compared to
         508                 :  * @return  TRUE if EQUAL
         509                 :  */
         510               0 : bool nsDequeIterator::operator==(nsDequeIterator& aIter) {
         511               0 :   return bool(((mIndex==aIter.mIndex) && (&mDeque==&aIter.mDeque)));
         512                 : }
         513                 :
         514                 : /**
         515                 :  * Compare two iterators for non strict decreasing order.
         516                 :  *
         517                 :  * @param   aIter is the other iterator to be compared to
         518                 :  * @return  TRUE if this object points to the same element, or
         519                 :  *          an element after the element pointed to by aIter.
         520                 :  *          FALSE if this and aIter are not iterating over the same deque.
         521                 :  */
         522               0 : bool nsDequeIterator::operator>=(nsDequeIterator& aIter) {
         523               0 :   return bool(((mIndex>=aIter.mIndex) && (&mDeque==&aIter.mDeque)));
         524                 : }
         525                 :
         526                 : /**
         527                 :  * Pre-increment operator
         528                 :  *
         529                 :  * @return  object at post-incremented index
         530                 :  */
         531               0 : void* nsDequeIterator::operator++() {
         532               0 :   NS_ASSERTION(mIndex<mDeque.mSize,
         533                 :     "You have reached the end of the Internet."\
         534                 :     "You have seen everything there is to see. Please go back. Now."
         535                 :   );
         536                 : #ifndef TIMELESS_LIGHTWEIGHT
         537               0 :   if (mIndex>=mDeque.mSize) return 0;
         538                 : #endif
         539               0 :   return mDeque.ObjectAt(++mIndex);
         540                 : }
         541                 :
         542                 : /**
         543                 :  * Post-increment operator
         544                 :  *
         545                 :  * @param   param is ignored
         546                 :  * @return  object at pre-incremented index
         547                 :  */
         548               0 : void* nsDequeIterator::operator++(int) {
         549               0 :   NS_ASSERTION(mIndex<=mDeque.mSize,
         550                 :     "You have already reached the end of the Internet."\
         551                 :     "You have seen everything there is to see. Please go back. Now."
         552                 :   );
         553                 : #ifndef TIMELESS_LIGHTWEIGHT
         554               0 :   if (mIndex>mDeque.mSize) return 0;
         555                 : #endif
         556               0 :   return mDeque.ObjectAt(mIndex++);
         557                 : }
         558                 :
         559                 : /**
         560                 :  * Pre-decrement operator
         561                 :  *
         562                 :  * @return  object at pre-decremented index
         563                 :  */
         564               0 : void* nsDequeIterator::operator--() {
         565               0 :   NS_ASSERTION(mIndex>=0,
         566                 :     "You have reached the beginning of the Internet."\
         567                 :     "You have seen everything there is to see. Please go forward. Now."
         568                 :   );
         569                 : #ifndef TIMELESS_LIGHTWEIGHT
         570               0 :   if (mIndex<0) return 0;
         571                 : #endif
         572               0 :   return mDeque.ObjectAt(--mIndex);
         573                 : }
         574                 :
         575                 : /**
         576                 :  * Post-decrement operator
         577                 :  *
         578                 :  * @param   param is ignored
         579                 :  * @return  object at post-decremented index
         580                 :  */
         581               0 : void* nsDequeIterator::operator--(int) {
         582               0 :   NS_ASSERTION(mIndex>=0,
         583                 :     "You have already reached the beginning of the Internet."\
         584                 :     "You have seen everything there is to see. Please go forward. Now."
         585                 :   );
         586                 : #ifndef TIMELESS_LIGHTWEIGHT
         587               0 :   if (mIndex<0) return 0;
         588                 : #endif
         589               0 :   return mDeque.ObjectAt(mIndex--);
         590                 : }
         591                 :
         592                 : /**
         593                 :  * Dereference operator
         594                 :  * Note that the iterator floats, so you don't need to do:
         595                 :  * <code>++iter; aDeque.PopFront();</code>
         596                 :  * Unless you actually want your iterator to jump 2 spaces.
         597                 :  *
         598                 :  * Picture: [1 2I 3 4]
         599                 :  * PopFront()
         600                 :  * Picture: [2 3I 4]
         601                 :  * Note that I still happily points to object at the second index
         602                 :  *
         603                 :  * @return  object at ith index
         604                 :  */
         605               0 : void* nsDequeIterator::GetCurrent() {
         606               0 :   NS_ASSERTION(mIndex<mDeque.mSize&&mIndex>=0,"Current is out of bounds");
         607                 : #ifndef TIMELESS_LIGHTWEIGHT
         608               0 :   if (mIndex>=mDeque.mSize||mIndex<0) return 0;
         609                 : #endif
         610               0 :   return mDeque.ObjectAt(mIndex);
         611                 : }
         612                 :
         613                 : /**
         614                 :  * Call this method when you want to iterate all the
         615                 :  * members of the container, passing a functor along
         616                 :  * to call your code.
         617                 :  *
         618                 :  * @param   aFunctor object to call for each member
         619                 :  * @return  *this
         620                 :  */
         621               0 : void nsDequeIterator::ForEach(nsDequeFunctor& aFunctor) const{
         622               0 :   mDeque.ForEach(aFunctor);
         623               0 : }
         624                 :
         625                 : /**
         626                 :  * Call this method when you want to iterate all the
         627                 :  * members of the container, calling the functor you
         628                 :  * passed with each member. This process will interrupt
         629                 :  * if your function returns non 0 to this method.
         630                 :  *
         631                 :  * @param   aFunctor object to call for each member
         632                 :  * @return  first nonzero result of aFunctor or 0.
         633                 :  */
         634               0 : const void* nsDequeIterator::FirstThat(nsDequeFunctor& aFunctor) const{
         635               0 :   return mDeque.FirstThat(aFunctor);
         636                 : }

Generated by: LCOV version 1.7