The Tor Browser: comparison xpcom/glue/nsDeque.cpp

--1:000000000000
+:270dc7c0bbdc
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsDeque.h"
+#include "nsISupportsImpl.h"
+#include <string.h>
+#ifdef DEBUG_rickg
+#include <stdio.h>
+#endif
+/**
+* 07/02/2001  09:17p 509,104 clangref.pdf from openwatcom's site
+* Watcom C Language Reference Edition 11.0c
+* page 118 of 297
+*
+* The % symbol yields the remainder from the division of the first operand
+* by the second operand. The operands of % must have integral type.
+*
+* When both operands of % are positive, the result is a positive value
+* smaller than the second operand. When one or both operands is negative,
+* whether the result is positive or negative is implementation-defined.
+*
+*/
+/* Ok, so first of all, C is underspecified. joy.
+* The following functions do not provide a correct implementation of modulus
+* They provide functionality for x>-y.
+* There are risks of 2*y being greater than max int, which is part of the
+* reason no multiplication is used and other operations are avoided.
+*
+* modasgn
+* @param x variable
+* @param y expression
+* approximately equivalent to x %= y
+*
+* modulus
+* @param x expression
+* @param y expression
+* approximately equivalent to x % y
+*/
+#define modasgn(x,y) if (x<0) x+=y; x%=y
+#define modulus(x,y) ((x<0)?(x+y)%(y):(x)%(y))
+/**
+* Standard constructor
+* @param deallocator, called by Erase and ~nsDeque
+*/
+nsDeque::nsDeque(nsDequeFunctor* aDeallocator) {
+MOZ_COUNT_CTOR(nsDeque);
+mDeallocator=aDeallocator;
+mOrigin=mSize=0;
+mData=mBuffer; // don't allocate space until you must
+mCapacity=sizeof(mBuffer)/sizeof(mBuffer[0]);
+memset(mData, 0, mCapacity*sizeof(mBuffer[0]));
+}
+/**
+* Destructor
+*/
+nsDeque::~nsDeque() {
+MOZ_COUNT_DTOR(nsDeque);
+#ifdef DEBUG_rickg
+char buffer[30];
+printf("Capacity: %i\n", mCapacity);
+static int mCaps[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+switch(mCapacity) {
+case 4:     mCaps[0]++; break;
+case 8:     mCaps[1]++; break;
+case 16:    mCaps[2]++; break;
+case 32:    mCaps[3]++; break;
+case 64:    mCaps[4]++; break;
+case 128:   mCaps[5]++; break;
+case 256:   mCaps[6]++; break;
+case 512:   mCaps[7]++; break;
+case 1024:  mCaps[8]++; break;
+case 2048:  mCaps[9]++; break;
+case 4096:  mCaps[10]++; break;
+default:
+break;
+}
+#endif
+Erase();
+if (mData && (mData!=mBuffer)) {
+free(mData);
+}
+mData=0;
+SetDeallocator(0);
+}
+size_t nsDeque::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+size_t size = 0;
+if (mData != mBuffer) {
+size += aMallocSizeOf(mData);
+}
+if (mDeallocator) {
+size += aMallocSizeOf(mDeallocator);
+}
+return size;
+}
+size_t nsDeque::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+/**
+* Set the functor to be called by Erase()
+* The deque owns the functor.
+*
+* @param   aDeallocator functor object for use by Erase()
+*/
+void nsDeque::SetDeallocator(nsDequeFunctor* aDeallocator){
+delete mDeallocator;
+mDeallocator=aDeallocator;
+}
+/**
+* Remove all items from container without destroying them.
+*/
+void nsDeque::Empty() {
+if (mSize && mData) {
+memset(mData, 0, mCapacity*sizeof(mData));
+}
+mSize=0;
+mOrigin=0;
+}
+/**
+* Remove and delete all items from container
+*/
+void nsDeque::Erase() {
+if (mDeallocator && mSize) {
+ForEach(*mDeallocator);
+}
+Empty();
+}
+/**
+* This method quadruples the size of the deque
+* Elements in the deque are resequenced so that elements
+* in the deque are stored sequentially
+*
+* @return  whether growing succeeded
+*/
+bool nsDeque::GrowCapacity() {
+int32_t theNewSize=mCapacity<<2;
+NS_ASSERTION(theNewSize>mCapacity, "Overflow");
+if (theNewSize<=mCapacity)
+return false;
+void** temp=(void**)malloc(theNewSize * sizeof(void*));
+if (!temp)
+return false;
+//Here's the interesting part: You can't just move the elements
+//directly (in situ) from the old buffer to the new one.
+//Since capacity has changed, the old origin doesn't make
+//sense anymore. It's better to resequence the elements now.
+memcpy(temp, mData + mOrigin, sizeof(void*) * (mCapacity - mOrigin));
+memcpy(temp + (mCapacity - mOrigin), mData, sizeof(void*) * mOrigin);
+if (mData != mBuffer) {
+free(mData);
+}
+mCapacity=theNewSize;
+mOrigin=0; //now realign the origin...
+mData=temp;
+return true;
+}
+/**
+* This method adds an item to the end of the deque.
+* This operation has the potential to cause the
+* underlying buffer to resize.
+*
+* @param   aItem: new item to be added to deque
+*/
+bool nsDeque::Push(void* aItem, const fallible_t&) {
+if (mSize==mCapacity && !GrowCapacity()) {
+return false;
+}
+mData[modulus(mOrigin + mSize, mCapacity)]=aItem;
+mSize++;
+return true;
+}
+/**
+* This method adds an item to the front of the deque.
+* This operation has the potential to cause the
+* underlying buffer to resize.
+*
+* --Commments for GrowCapacity() case
+* We've grown and shifted which means that the old
+* final element in the deque is now the first element
+* in the deque.  This is temporary.
+* We haven't inserted the new element at the front.
+*
+* To continue with the idea of having the front at zero
+* after a grow, we move the old final item (which through
+* the voodoo of mOrigin-- is now the first) to its final
+* position which is conveniently the old length.
+*
+* Note that this case only happens when the deque is full.
+* [And that pieces of this magic only work if the deque is full.]
+* picture:
+*   [ABCDEFGH] @[mOrigin:3]:D.
+* Task: PushFront("Z")
+* shift mOrigin so, @[mOrigin:2]:C
+* stretch and rearrange: (mOrigin:0)
+*   [CDEFGHAB ________ ________ ________]
+* copy: (The second C is currently out of bounds)
+*   [CDEFGHAB C_______ ________ ________]
+* later we will insert Z:
+*   [ZDEFGHAB C_______ ________ ________]
+* and increment size: 9. (C is no longer out of bounds)
+* --
+* @param   aItem: new item to be added to deque
+*/
+bool nsDeque::PushFront(void* aItem, const fallible_t&) {
+mOrigin--;
+modasgn(mOrigin,mCapacity);
+if (mSize==mCapacity) {
+if (!GrowCapacity()) {
+return false;
+}
+/* Comments explaining this are above*/
+mData[mSize]=mData[mOrigin];
+}
+mData[mOrigin]=aItem;
+mSize++;
+return true;
+}
+/**
+* Remove and return the last item in the container.
+*
+* @return  ptr to last item in container
+*/
+void* nsDeque::Pop() {
+void* result=0;
+if (mSize>0) {
+--mSize;
+int32_t offset=modulus(mSize + mOrigin, mCapacity);
+result=mData[offset];
+mData[offset]=0;
+if (!mSize) {
+mOrigin=0;
+}
+}
+return result;
+}
+/**
+* This method gets called you want to remove and return
+* the first member in the container.
+*
+* @return  last item in container
+*/
+void* nsDeque::PopFront() {
+void* result=0;
+if (mSize>0) {
+NS_ASSERTION(mOrigin < mCapacity, "Error: Bad origin");
+result=mData[mOrigin];
+mData[mOrigin++]=0;     //zero it out for debugging purposes.
+mSize--;
+// Cycle around if we pop off the end
+// and reset origin if when we pop the last element
+if (mCapacity==mOrigin || !mSize) {
+mOrigin=0;
+}
+}
+return result;
+}
+/**
+* This method gets called you want to peek at the bottom
+* member without removing it.
+*
+* @return  last item in container
+*/
+void* nsDeque::Peek() {
+void* result=0;
+if (mSize>0) {
+result = mData[modulus(mSize - 1 + mOrigin, mCapacity)];
+}
+return result;
+}
+/**
+* This method gets called you want to peek at the topmost
+* member without removing it.
+*
+* @return  last item in container
+*/
+void* nsDeque::PeekFront() {
+void* result=0;
+if (mSize>0) {
+result=mData[mOrigin];
+}
+return result;
+}
+/**
+* Call this to retrieve the ith element from this container.
+* Keep in mind that accessing the underlying elements is
+* done in a relative fashion. Object 0 is not necessarily
+* the first element (the first element is at mOrigin).
+*
+* @param   aIndex : 0 relative offset of item you want
+* @return  void* or null
+*/
+void* nsDeque::ObjectAt(int32_t aIndex) const {
+void* result=0;
+if ((aIndex>=0) && (aIndex<mSize)) {
+result=mData[modulus(mOrigin + aIndex, mCapacity)];
+}
+return result;
+}
+void* nsDeque::RemoveObjectAt(int32_t aIndex) {
+if ((aIndex<0) || (aIndex>=mSize)) {
+return 0;
+}
+void* result=mData[modulus(mOrigin + aIndex, mCapacity)];
+// "Shuffle down" all elements in the array by 1, overwritting the element
+// being removed.
+for (int32_t i=aIndex; i<mSize; i++) {
+mData[modulus(mOrigin + i, mCapacity)] = mData[modulus(mOrigin + i + 1, mCapacity)];
+}
+mSize--;
+return result;
+}
+/**
+* Create and return an iterator pointing to
+* the beginning of the queue. Note that this
+* takes the circular buffer semantics into account.
+*
+* @return  new deque iterator, init'ed to 1st item
+*/
+nsDequeIterator nsDeque::Begin() const{
+return nsDequeIterator(*this, 0);
+}
+/**
+* Create and return an iterator pointing to
+* the last item in the deque.
+* Note that this takes the circular buffer semantics
+* into account.
+*
+* @return  new deque iterator, init'ed to the last item
+*/
+nsDequeIterator nsDeque::End() const{
+return nsDequeIterator(*this, mSize - 1);
+}
+void* nsDeque::Last() const {
+return End().GetCurrent();
+}
+/**
+* Call this method when you want to iterate all the
+* members of the container, passing a functor along
+* to call your code.
+*
+* @param   aFunctor object to call for each member
+* @return  *this
+*/
+void nsDeque::ForEach(nsDequeFunctor& aFunctor) const{
+for (int32_t i=0; i<mSize; i++) {
+aFunctor(ObjectAt(i));
+}
+}
+/**
+* Call this method when you want to iterate all the
+* members of the container, calling the functor you
+* passed with each member. This process will interrupt
+* if your function returns non 0 to this method.
+*
+* @param   aFunctor object to call for each member
+* @return  first nonzero result of aFunctor or 0.
+*/
+const void* nsDeque::FirstThat(nsDequeFunctor& aFunctor) const{
+for (int32_t i=0; i<mSize; i++) {
+void* obj=aFunctor(ObjectAt(i));
+if (obj) {
+return obj;
+}
+}
+return 0;
+}
+/******************************************************
+* Here comes the nsDequeIterator class...
+******************************************************/
+/**
+* DequeIterator is an object that knows how to iterate (forward and backward)
+* through a Deque. Normally, you don't need to do this, but there are some special
+* cases where it is pretty handy, so here you go.
+*
+* This is a standard dequeiterator constructor
+*
+* @param   aQueue is the deque object to be iterated
+* @param   aIndex is the starting position for your iteration
+*/
+nsDequeIterator::nsDequeIterator(const nsDeque& aQueue, int aIndex)
+: mIndex(aIndex),
+mDeque(aQueue)
+{
+}
+/**
+* Create a copy of a DequeIterator
+*
+* @param   aCopy is another iterator to copy from
+*/
+nsDequeIterator::nsDequeIterator(const nsDequeIterator& aCopy)
+: mIndex(aCopy.mIndex),
+mDeque(aCopy.mDeque)
+{
+}
+/**
+* Moves iterator to first element in deque
+* @return  *this
+*/
+nsDequeIterator& nsDequeIterator::First(){
+mIndex=0;
+return *this;
+}
+/**
+* Standard assignment operator for dequeiterator
+*
+* @param   aCopy is an iterator to be copied from
+* @return  *this
+*/
+nsDequeIterator& nsDequeIterator::operator=(const nsDequeIterator& aCopy) {
+NS_ASSERTION(&mDeque==&aCopy.mDeque,"you can't change the deque that an interator is iterating over, sorry.");
+mIndex=aCopy.mIndex;
+return *this;
+}
+/**
+* preform ! operation against to iterators to test for equivalence
+* (or lack thereof)!
+*
+* @param   aIter is the object to be compared to
+* @return  TRUE if NOT equal.
+*/
+bool nsDequeIterator::operator!=(nsDequeIterator& aIter) {
+return bool(!this->operator==(aIter));
+}
+/**
+* Compare two iterators for increasing order.
+*
+* @param   aIter is the other iterator to be compared to
+* @return  TRUE if this object points to an element before
+*          the element pointed to by aIter.
+*          FALSE if this and aIter are not iterating over the same deque.
+*/
+bool nsDequeIterator::operator<(nsDequeIterator& aIter) {
+return bool(((mIndex<aIter.mIndex) && (&mDeque==&aIter.mDeque)));
+}
+/**
+* Compare two iterators for equivalence.
+*
+* @param   aIter is the other iterator to be compared to
+* @return  TRUE if EQUAL
+*/
+bool nsDequeIterator::operator==(nsDequeIterator& aIter) {
+return bool(((mIndex==aIter.mIndex) && (&mDeque==&aIter.mDeque)));
+}
+/**
+* Compare two iterators for non strict decreasing order.
+*
+* @param   aIter is the other iterator to be compared to
+* @return  TRUE if this object points to the same element, or
+*          an element after the element pointed to by aIter.
+*          FALSE if this and aIter are not iterating over the same deque.
+*/
+bool nsDequeIterator::operator>=(nsDequeIterator& aIter) {
+return bool(((mIndex>=aIter.mIndex) && (&mDeque==&aIter.mDeque)));
+}
+/**
+* Pre-increment operator
+*
+* @return  object at post-incremented index
+*/
+void* nsDequeIterator::operator++() {
+NS_ASSERTION(mIndex<mDeque.mSize,
+"You have reached the end of the Internet."\
+"You have seen everything there is to see. Please go back. Now."
+);
+#ifndef TIMELESS_LIGHTWEIGHT
+if (mIndex>=mDeque.mSize) return 0;
+#endif
+return mDeque.ObjectAt(++mIndex);
+}
+/**
+* Post-increment operator
+*
+* @param   param is ignored
+* @return  object at pre-incremented index
+*/
+void* nsDequeIterator::operator++(int) {
+NS_ASSERTION(mIndex<=mDeque.mSize,
+"You have already reached the end of the Internet."\
+"You have seen everything there is to see. Please go back. Now."
+);
+#ifndef TIMELESS_LIGHTWEIGHT
+if (mIndex>mDeque.mSize) return 0;
+#endif
+return mDeque.ObjectAt(mIndex++);
+}
+/**
+* Pre-decrement operator
+*
+* @return  object at pre-decremented index
+*/
+void* nsDequeIterator::operator--() {
+NS_ASSERTION(mIndex>=0,
+"You have reached the beginning of the Internet."\
+"You have seen everything there is to see. Please go forward. Now."
+);
+#ifndef TIMELESS_LIGHTWEIGHT
+if (mIndex<0) return 0;
+#endif
+return mDeque.ObjectAt(--mIndex);
+}
+/**
+* Post-decrement operator
+*
+* @param   param is ignored
+* @return  object at post-decremented index
+*/
+void* nsDequeIterator::operator--(int) {
+NS_ASSERTION(mIndex>=0,
+"You have already reached the beginning of the Internet."\
+"You have seen everything there is to see. Please go forward. Now."
+);
+#ifndef TIMELESS_LIGHTWEIGHT
+if (mIndex<0) return 0;
+#endif
+return mDeque.ObjectAt(mIndex--);
+}
+/**
+* Dereference operator
+* Note that the iterator floats, so you don't need to do:
+* <code>++iter; aDeque.PopFront();</code>
+* Unless you actually want your iterator to jump 2 spaces.
+*
+* Picture: [1 2I 3 4]
+* PopFront()
+* Picture: [2 3I 4]
+* Note that I still happily points to object at the second index
+*
+* @return  object at ith index
+*/
+void* nsDequeIterator::GetCurrent() {
+NS_ASSERTION(mIndex<mDeque.mSize&&mIndex>=0,"Current is out of bounds");
+#ifndef TIMELESS_LIGHTWEIGHT
+if (mIndex>=mDeque.mSize||mIndex<0) return 0;
+#endif
+return mDeque.ObjectAt(mIndex);
+}
+/**
+* Call this method when you want to iterate all the
+* members of the container, passing a functor along
+* to call your code.
+*
+* @param   aFunctor object to call for each member
+* @return  *this
+*/
+void nsDequeIterator::ForEach(nsDequeFunctor& aFunctor) const{
+mDeque.ForEach(aFunctor);
+}
+/**
+* Call this method when you want to iterate all the
+* members of the container, calling the functor you
+* passed with each member. This process will interrupt
+* if your function returns non 0 to this method.
+*
+* @param   aFunctor object to call for each member
+* @return  first nonzero result of aFunctor or 0.
+*/
+const void* nsDequeIterator::FirstThat(nsDequeFunctor& aFunctor) const{
+return mDeque.FirstThat(aFunctor);
+}

The Tor Browser / file comparison

comparison: xpcom/glue/nsDeque.cpp

xpcom/glue/nsDeque.cpp