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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/* -*- 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/. */
#include "mozilla/Attributes.h"
#include "nsArrayEnumerator.h"
#include "nsIArray.h"
#include "nsSimpleEnumerator.h"
#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/RefPtr.h"
class nsSimpleArrayEnumerator final : public nsSimpleEnumerator {
public:
// nsISimpleEnumerator interface
NS_DECL_NSISIMPLEENUMERATOR
// nsSimpleArrayEnumerator methods
explicit nsSimpleArrayEnumerator(nsIArray* aValueArray, const nsID& aEntryIID)
: mValueArray(aValueArray), mEntryIID(aEntryIID), mIndex(0) {}
const nsID& DefaultInterface() override { return mEntryIID; }
private:
~nsSimpleArrayEnumerator() override = default;
protected:
nsCOMPtr<nsIArray> mValueArray;
const nsID mEntryIID;
uint32_t mIndex;
};
NS_IMETHODIMP
nsSimpleArrayEnumerator::HasMoreElements(bool* aResult) {
MOZ_ASSERT(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
if (!mValueArray) {
*aResult = false;
return NS_OK;
}
uint32_t cnt;
nsresult rv = mValueArray->GetLength(&cnt);
if (NS_FAILED(rv)) {
return rv;
}
*aResult = (mIndex < cnt);
return NS_OK;
}
NS_IMETHODIMP
nsSimpleArrayEnumerator::GetNext(nsISupports** aResult) {
MOZ_ASSERT(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
if (!mValueArray) {
*aResult = nullptr;
return NS_OK;
}
uint32_t cnt;
nsresult rv = mValueArray->GetLength(&cnt);
if (NS_FAILED(rv)) {
return rv;
}
if (mIndex >= cnt) {
return NS_ERROR_UNEXPECTED;
}
return mValueArray->QueryElementAt(mIndex++, NS_GET_IID(nsISupports),
(void**)aResult);
}
nsresult NS_NewArrayEnumerator(nsISimpleEnumerator** aResult, nsIArray* aArray,
const nsID& aEntryIID) {
RefPtr<nsSimpleArrayEnumerator> enumer =
new nsSimpleArrayEnumerator(aArray, aEntryIID);
enumer.forget(aResult);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// enumerator implementation for nsCOMArray
// creates a snapshot of the array in question
// you MUST use NS_NewArrayEnumerator to create this, so that
// allocation is done correctly
class nsCOMArrayEnumerator final : public nsSimpleEnumerator {
public:
// nsISimpleEnumerator interface
NS_DECL_NSISIMPLEENUMERATOR
// Use this instead of `new`.
static nsCOMArrayEnumerator* Allocate(const nsCOMArray_base& aArray,
const nsID& aEntryIID);
// specialized operator to make sure we make room for mValues
void operator delete(void* aPtr) { free(aPtr); }
const nsID& DefaultInterface() override { return mEntryIID; }
private:
// nsSimpleArrayEnumerator methods
explicit nsCOMArrayEnumerator(const nsID& aEntryIID)
: mIndex(0), mArraySize(0), mEntryIID(aEntryIID) {
mValueArray[0] = nullptr;
}
~nsCOMArrayEnumerator(void) override;
protected:
uint32_t mIndex; // current position
uint32_t mArraySize; // size of the array
const nsID& mEntryIID;
// this is actually bigger
nsISupports* mValueArray[1];
};
nsCOMArrayEnumerator::~nsCOMArrayEnumerator() {
// only release the entries that we haven't visited yet
for (; mIndex < mArraySize; ++mIndex) {
NS_IF_RELEASE(mValueArray[mIndex]);
}
}
NS_IMETHODIMP
nsCOMArrayEnumerator::HasMoreElements(bool* aResult) {
MOZ_ASSERT(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
*aResult = (mIndex < mArraySize);
return NS_OK;
}
NS_IMETHODIMP
nsCOMArrayEnumerator::GetNext(nsISupports** aResult) {
MOZ_ASSERT(aResult != 0, "null ptr");
if (!aResult) {
return NS_ERROR_NULL_POINTER;
}
if (mIndex >= mArraySize) {
return NS_ERROR_UNEXPECTED;
}
// pass the ownership of the reference to the caller. Since
// we AddRef'ed during creation of |this|, there is no need
// to AddRef here
*aResult = mValueArray[mIndex++];
// this really isn't necessary. just pretend this happens, since
// we'll never visit this value again!
// mValueArray[(mIndex-1)] = nullptr;
return NS_OK;
}
nsCOMArrayEnumerator* nsCOMArrayEnumerator::Allocate(
const nsCOMArray_base& aArray, const nsID& aEntryIID) {
// create enough space such that mValueArray points to a large
// enough value. Note that the initial value of aSize gives us
// space for mValueArray[0], so we must subtract
size_t size = sizeof(nsCOMArrayEnumerator);
uint32_t count;
if (aArray.Count() > 0) {
count = static_cast<uint32_t>(aArray.Count());
size += (count - 1) * sizeof(aArray[0]);
} else {
count = 0;
}
// Allocate a buffer large enough to contain our object and its array.
void* mem = moz_xmalloc(size);
auto result =
new (mozilla::KnownNotNull, mem) nsCOMArrayEnumerator(aEntryIID);
result->mArraySize = count;
// now need to copy over the values, and addref each one
// now this might seem like a lot of work, but we're actually just
// doing all our AddRef's ahead of time since GetNext() doesn't
// need to AddRef() on the way out
for (uint32_t i = 0; i < count; ++i) {
result->mValueArray[i] = aArray[i];
NS_IF_ADDREF(result->mValueArray[i]);
}
return result;
}
nsresult NS_NewArrayEnumerator(nsISimpleEnumerator** aResult,
const nsCOMArray_base& aArray,
const nsID& aEntryIID) {
RefPtr<nsCOMArrayEnumerator> enumerator =
nsCOMArrayEnumerator::Allocate(aArray, aEntryIID);
enumerator.forget(aResult);
return NS_OK;
}
|
