Bug 1336215 - More complete and consistent nsDeque doc, deleted special copy members - r=froydnj
authorGerald Squelart <gsquelart@mozilla.com>
Fri, 03 Feb 2017 12:43:13 +1100
changeset 341120 f321cc0af9040fa75e93756fe44b433e8a4fd6ab
parent 341119 4f30316c8432bdab8bc555e3551b695d62182069
child 341121 d969e512cd1ddac2e2701510d2008021736a270c
push id86634
push usercbook@mozilla.com
push dateTue, 07 Feb 2017 13:14:58 +0000
treeherdermozilla-inbound@9dbd2d9b334e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1336215
milestone54.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1336215 - More complete and consistent nsDeque doc, deleted special copy members - r=froydnj MozReview-Commit-ID: GvjFPiX6lii
xpcom/ds/nsDeque.h
--- a/xpcom/ds/nsDeque.h
+++ b/xpcom/ds/nsDeque.h
@@ -3,46 +3,44 @@
 /* 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/. */
 
 /**
  * MODULE NOTES:
  *
  * The Deque is a very small, very efficient container object
- * than can hold elements of type void*, offering the following features:
- *    Its interface supports pushing and popping of elements.
- *    It can iterate (via an interator class) its elements.
- *    When full, it can efficiently resize dynamically.
- *
+ * than can hold items of type void*, offering the following features:
+ * - Its interface supports pushing, popping, and peeking of items at the back
+ *   or front, and retrieval from any position.
+ * - It can iterate over items via a ForEach method, range-for, or an iterator
+ *   class.
+ * - When full, it can efficiently resize dynamically.
  *
  * NOTE: The only bit of trickery here is that this deque is
  * built upon a ring-buffer. Like all ring buffers, the first
- * element may not be at index[0]. The mOrigin member determines
+ * item may not be at index[0]. The mOrigin member determines
  * where the first child is. This point is quietly hidden from
  * customers of this class.
- *
  */
 
 #ifndef _NSDEQUE
 #define _NSDEQUE
 
 #include "nscore.h"
 #include "nsDebug.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/fallible.h"
 #include "mozilla/MemoryReporting.h"
 
 /**
  * The nsDequeFunctor class is used when you want to create
  * callbacks between the deque and your generic code.
- * Use these objects in a call to ForEach();
- *
+ * Use these objects in a call to ForEach(), and as custom deallocators.
  */
-
 class nsDequeFunctor
 {
 public:
   virtual void* operator()(void* aObject) = 0;
   virtual ~nsDequeFunctor() {}
 };
 
 /******************************************************
@@ -53,58 +51,81 @@ public:
  * The deque (double-ended queue) class is a common container type,
  * whose behavior mimics a line in your favorite checkout stand.
  * Classic CS describes the common behavior of a queue as FIFO.
  * A deque allows insertion and removal at both ends of
  * the container.
  *
  * The deque stores pointers to items.
  */
-
 class nsDeque
 {
   typedef mozilla::fallible_t fallible_t;
 public:
+  /**
+   * Constructs an empty deque.
+   *
+   * @param   aDeallocator Optional deallocator functor that will be called from
+   *                       Erase() and the destructor on any remaining item.
+   *                       The deallocator is owned by the deque and will be
+   *                       deleted at destruction time.
+   */
   explicit nsDeque(nsDequeFunctor* aDeallocator = nullptr);
+
+  /**
+   * Deque destructor. Erases all items, deletes the deallocator.
+   */
   ~nsDeque();
 
   /**
-   * Returns the number of elements currently stored in
+   * Returns the number of items currently stored in
    * this deque.
    *
-   * @return  number of elements currently in the deque
+   * @return  number of items currently in the deque
    */
   inline size_t GetSize() const { return mSize; }
 
   /**
    * Appends new member at the end of the deque.
    *
-   * @param   item to store in deque
+   * @param   aItem item to store in deque
    */
   void Push(void* aItem)
   {
     if (!Push(aItem, mozilla::fallible)) {
       NS_ABORT_OOM(mSize * sizeof(void*));
     }
   }
 
+  /**
+   * Appends new member at the end of the deque.
+   *
+   * @param   aItem item to store in deque
+   * @return  true if succeeded, false if failed to resize deque as needed
+   */
   MOZ_MUST_USE bool Push(void* aItem, const fallible_t&);
 
   /**
    * Inserts new member at the front of the deque.
    *
-   * @param   item to store in deque
+   * @param   aItem item to store in deque
    */
   void PushFront(void* aItem)
   {
     if (!PushFront(aItem, mozilla::fallible)) {
       NS_ABORT_OOM(mSize * sizeof(void*));
     }
   }
 
+  /**
+   * Inserts new member at the front of the deque.
+   *
+   * @param   aItem item to store in deque
+   * @return  true if succeeded, false if failed to resize deque as needed
+   */
   MOZ_MUST_USE bool PushFront(void* aItem, const fallible_t&);
 
   /**
    * Remove and return the last item in the container.
    *
    * @return  the item that was the last item in container
    */
   void* Pop();
@@ -112,47 +133,47 @@ public:
   /**
    * Remove and return the first item in the container.
    *
    * @return  the item that was first item in container
    */
   void* PopFront();
 
   /**
-   * Retrieve the bottom item without removing it.
+   * Retrieve the last item without removing it.
    *
-   * @return  the first item in container
+   * @return  the last item in container
    */
+  void* Peek() const;
 
-  void* Peek() const;
   /**
-   * Return topmost item without removing it.
+   * Retrieve the first item without removing it.
    *
    * @return  the first item in container
    */
   void* PeekFront() const;
 
   /**
    * Retrieve a member from the deque without removing it.
    *
    * @param   index of desired item
-   * @return  element in list
+   * @return  item in list, or nullptr if index is outside the deque
    */
   void* ObjectAt(size_t aIndex) const;
 
   /**
    * Remove and delete all items from container.
    * Deletes are handled by the deallocator nsDequeFunctor
    * which is specified at deque construction.
    */
   void Erase();
 
   /**
-   * Call this method when you want to iterate all the
-   * members of the container, passing a functor along
+   * Call this method when you want to iterate through all
+   * items in the container, passing a functor along
    * to call your code.
    *
    * @param   aFunctor object to call for each member
    */
   void ForEach(nsDequeFunctor& aFunctor) const;
 
   class ConstIterator
   {
@@ -178,29 +199,29 @@ protected:
   size_t         mOrigin;
   nsDequeFunctor* mDeallocator;
   void*           mBuffer[8];
   void**          mData;
 
 private:
 
   /**
-   * Copy constructor (PRIVATE)
+   * Copy constructor (deleted)
    *
    * @param aOther another deque
    */
-  nsDeque(const nsDeque& aOther);
+  nsDeque(const nsDeque& aOther) = delete;
 
   /**
-   * Deque assignment operator (PRIVATE)
+   * Deque assignment operator (deleted)
    *
    * @param aOther another deque
    * @return *this
    */
-  nsDeque& operator=(const nsDeque& aOther);
+  nsDeque& operator=(const nsDeque& aOther) = delete;
 
   bool GrowCapacity();
   void SetDeallocator(nsDequeFunctor* aDeallocator);
 
   /**
    * Remove all items from container without destroying them.
    */
   void Empty();