1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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.
*
*
* 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
* 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();
*
*/
class nsDequeFunctor
{
public:
virtual void* operator()(void* aObject) = 0;
virtual ~nsDequeFunctor() {}
};
/******************************************************
* Here comes the nsDeque class itself...
******************************************************/
/**
* 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 nsDequeIterator;
class nsDeque
{
typedef mozilla::fallible_t fallible_t;
public:
explicit nsDeque(nsDequeFunctor* aDeallocator = nullptr);
~nsDeque();
/**
* Returns the number of elements currently stored in
* this deque.
*
* @return number of elements 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
*/
void Push(void* aItem)
{
if (!Push(aItem, mozilla::fallible)) {
NS_ABORT_OOM(mSize * sizeof(void*));
}
}
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
*/
void PushFront(void* aItem)
{
if (!PushFront(aItem, mozilla::fallible)) {
NS_ABORT_OOM(mSize * sizeof(void*));
}
}
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();
/**
* 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.
*
* @return the first item in container
*/
void* Peek() const;
/**
* Return topmost 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
*/
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
* to call your code.
*
* @param aFunctor object to call for each member
*/
void ForEach(nsDequeFunctor& aFunctor) const;
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
protected:
size_t mSize;
size_t mCapacity;
size_t mOrigin;
nsDequeFunctor* mDeallocator;
void* mBuffer[8];
void** mData;
private:
/**
* Copy constructor (PRIVATE)
*
* @param aOther another deque
*/
nsDeque(const nsDeque& aOther);
/**
* Deque assignment operator (PRIVATE)
*
* @param aOther another deque
* @return *this
*/
nsDeque& operator=(const nsDeque& aOther);
bool GrowCapacity();
void SetDeallocator(nsDequeFunctor* aDeallocator);
/**
* Remove all items from container without destroying them.
*/
void Empty();
};
#endif
|
