mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-11 02:56:06 +00:00
214 lines
5.3 KiB
C++
214 lines
5.3 KiB
C++
/* -*- 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 "nsISimpleEnumerator.h"
|
|
|
|
#include "nsCOMArray.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "mozilla/RefPtr.h"
|
|
|
|
class nsSimpleArrayEnumerator final : public nsISimpleEnumerator
|
|
{
|
|
public:
|
|
// nsISupports interface
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsISimpleEnumerator interface
|
|
NS_DECL_NSISIMPLEENUMERATOR
|
|
|
|
// nsSimpleArrayEnumerator methods
|
|
explicit nsSimpleArrayEnumerator(nsIArray* aValueArray)
|
|
: mValueArray(aValueArray)
|
|
, mIndex(0)
|
|
{
|
|
}
|
|
|
|
private:
|
|
~nsSimpleArrayEnumerator() {}
|
|
|
|
protected:
|
|
nsCOMPtr<nsIArray> mValueArray;
|
|
uint32_t mIndex;
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(nsSimpleArrayEnumerator, nsISimpleEnumerator)
|
|
|
|
NS_IMETHODIMP
|
|
nsSimpleArrayEnumerator::HasMoreElements(bool* aResult)
|
|
{
|
|
NS_PRECONDITION(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)
|
|
{
|
|
NS_PRECONDITION(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)
|
|
{
|
|
RefPtr<nsSimpleArrayEnumerator> enumer = new nsSimpleArrayEnumerator(aArray);
|
|
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 nsISimpleEnumerator
|
|
{
|
|
public:
|
|
// nsISupports interface
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsISimpleEnumerator interface
|
|
NS_DECL_NSISIMPLEENUMERATOR
|
|
|
|
// nsSimpleArrayEnumerator methods
|
|
nsCOMArrayEnumerator() : mIndex(0) {}
|
|
|
|
// specialized operator to make sure we make room for mValues
|
|
void* operator new(size_t aSize, const nsCOMArray_base& aArray) CPP_THROW_NEW;
|
|
void operator delete(void* aPtr) { ::operator delete(aPtr); }
|
|
|
|
private:
|
|
~nsCOMArrayEnumerator(void);
|
|
|
|
protected:
|
|
uint32_t mIndex; // current position
|
|
uint32_t mArraySize; // size of the array
|
|
|
|
// this is actually bigger
|
|
nsISupports* mValueArray[1];
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(nsCOMArrayEnumerator, nsISimpleEnumerator)
|
|
|
|
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)
|
|
{
|
|
NS_PRECONDITION(aResult != 0, "null ptr");
|
|
if (!aResult) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
*aResult = (mIndex < mArraySize);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsCOMArrayEnumerator::GetNext(nsISupports** aResult)
|
|
{
|
|
NS_PRECONDITION(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;
|
|
}
|
|
|
|
void*
|
|
nsCOMArrayEnumerator::operator new(size_t aSize,
|
|
const nsCOMArray_base& aArray) CPP_THROW_NEW
|
|
{
|
|
// 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
|
|
aSize += (aArray.Count() - 1) * sizeof(aArray[0]);
|
|
|
|
// do the actual allocation
|
|
nsCOMArrayEnumerator* result =
|
|
static_cast<nsCOMArrayEnumerator*>(::operator new(aSize));
|
|
|
|
// 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
|
|
uint32_t i;
|
|
uint32_t max = result->mArraySize = aArray.Count();
|
|
for (i = 0; i < max; ++i) {
|
|
result->mValueArray[i] = aArray[i];
|
|
NS_IF_ADDREF(result->mValueArray[i]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
nsresult
|
|
NS_NewArrayEnumerator(nsISimpleEnumerator** aResult,
|
|
const nsCOMArray_base& aArray)
|
|
{
|
|
RefPtr<nsCOMArrayEnumerator> enumerator = new (aArray) nsCOMArrayEnumerator();
|
|
enumerator.forget(aResult);
|
|
return NS_OK;
|
|
}
|