gecko-dev/xpcom/ds/nsCOMArray.cpp

/* -*- 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 "nsCOMArray.h"

#include "mozilla/MemoryReporting.h"
#include "mozilla/OperatorNewExtensions.h"
#include "nsQuickSort.h"

#include "nsCOMPtr.h"

// This specialization is private to nsCOMArray.
// It exists solely to automatically zero-out newly created array elements.
template <>
class nsTArrayElementTraits<nsISupports*> {
  typedef nsISupports* E;

 public:
  // Zero out the value
  static inline void Construct(E* aE) {
    new (mozilla::KnownNotNull, static_cast<void*>(aE)) E();
  }
  // Invoke the copy-constructor in place.
  template <class A>
  static inline void Construct(E* aE, const A& aArg) {
    new (mozilla::KnownNotNull, static_cast<void*>(aE)) E(aArg);
  }
  // Invoke the destructor in place.
  static inline void Destruct(E* aE) { aE->~E(); }
};

static void ReleaseObjects(nsTArray<nsISupports*>& aArray);

// implementations of non-trivial methods in nsCOMArray_base

nsCOMArray_base::nsCOMArray_base(const nsCOMArray_base& aOther) {
  // make sure we do only one allocation
  mArray.SetCapacity(aOther.Count());
  AppendObjects(aOther);
}

nsCOMArray_base::~nsCOMArray_base() { Clear(); }

int32_t nsCOMArray_base::IndexOf(nsISupports* aObject,
                                 uint32_t aStartIndex) const {
  return mArray.IndexOf(aObject, aStartIndex);
}

int32_t nsCOMArray_base::IndexOfObject(nsISupports* aObject) const {
  nsCOMPtr<nsISupports> supports = do_QueryInterface(aObject);
  if (NS_WARN_IF(!supports)) {
    return -1;
  }

  uint32_t i, count;
  int32_t retval = -1;
  count = mArray.Length();
  for (i = 0; i < count; ++i) {
    nsCOMPtr<nsISupports> arrayItem = do_QueryInterface(mArray[i]);
    if (arrayItem == supports) {
      retval = i;
      break;
    }
  }
  return retval;
}

bool nsCOMArray_base::EnumerateForwards(nsBaseArrayEnumFunc aFunc,
                                        void* aData) const {
  for (uint32_t index = 0; index < mArray.Length(); ++index) {
    if (!(*aFunc)(mArray[index], aData)) {
      return false;
    }
  }

  return true;
}

bool nsCOMArray_base::EnumerateBackwards(nsBaseArrayEnumFunc aFunc,
                                         void* aData) const {
  for (uint32_t index = mArray.Length(); index--;) {
    if (!(*aFunc)(mArray[index], aData)) {
      return false;
    }
  }

  return true;
}

int nsCOMArray_base::nsCOMArrayComparator(const void* aElement1,
                                          const void* aElement2, void* aData) {
  nsCOMArrayComparatorContext* ctx =
      static_cast<nsCOMArrayComparatorContext*>(aData);
  return (*ctx->mComparatorFunc)(*static_cast<nsISupports* const*>(aElement1),
                                 *static_cast<nsISupports* const*>(aElement2),
                                 ctx->mData);
}

void nsCOMArray_base::Sort(nsBaseArrayComparatorFunc aFunc, void* aData) {
  if (mArray.Length() > 1) {
    nsCOMArrayComparatorContext ctx = {aFunc, aData};
    NS_QuickSort(mArray.Elements(), mArray.Length(), sizeof(nsISupports*),
                 nsCOMArrayComparator, &ctx);
  }
}

bool nsCOMArray_base::InsertObjectAt(nsISupports* aObject, int32_t aIndex) {
  if ((uint32_t)aIndex > mArray.Length()) {
    return false;
  }

  if (!mArray.InsertElementAt(aIndex, aObject)) {
    return false;
  }

  NS_IF_ADDREF(aObject);
  return true;
}

void nsCOMArray_base::InsertElementAt(uint32_t aIndex, nsISupports* aElement) {
  mArray.InsertElementAt(aIndex, aElement);
  NS_IF_ADDREF(aElement);
}

void nsCOMArray_base::InsertElementAt(uint32_t aIndex,
                                      already_AddRefed<nsISupports> aElement) {
  mArray.InsertElementAt(aIndex, aElement.take());
}

bool nsCOMArray_base::InsertObjectsAt(const nsCOMArray_base& aObjects,
                                      int32_t aIndex) {
  if ((uint32_t)aIndex > mArray.Length()) {
    return false;
  }

  if (!mArray.InsertElementsAt(aIndex, aObjects.mArray)) {
    return false;
  }

  // need to addref all these
  uint32_t count = aObjects.Length();
  for (uint32_t i = 0; i < count; ++i) {
    NS_IF_ADDREF(aObjects[i]);
  }

  return true;
}

void nsCOMArray_base::InsertElementsAt(uint32_t aIndex,
                                       const nsCOMArray_base& aElements) {
  mArray.InsertElementsAt(aIndex, aElements.mArray);

  // need to addref all these
  uint32_t count = aElements.Length();
  for (uint32_t i = 0; i < count; ++i) {
    NS_IF_ADDREF(aElements[i]);
  }
}

void nsCOMArray_base::InsertElementsAt(uint32_t aIndex,
                                       nsISupports* const* aElements,
                                       uint32_t aCount) {
  mArray.InsertElementsAt(aIndex, aElements, aCount);

  // need to addref all these
  for (uint32_t i = 0; i < aCount; ++i) {
    NS_IF_ADDREF(aElements[i]);
  }
}

void nsCOMArray_base::ReplaceObjectAt(nsISupports* aObject, int32_t aIndex) {
  mArray.EnsureLengthAtLeast(aIndex + 1);
  nsISupports* oldObject = mArray[aIndex];
  // Make sure to addref first, in case aObject == oldObject
  NS_IF_ADDREF(mArray[aIndex] = aObject);
  NS_IF_RELEASE(oldObject);
}

bool nsCOMArray_base::RemoveObject(nsISupports* aObject) {
  bool result = mArray.RemoveElement(aObject);
  if (result) {
    NS_IF_RELEASE(aObject);
  }
  return result;
}

bool nsCOMArray_base::RemoveObjectAt(int32_t aIndex) {
  if (uint32_t(aIndex) < mArray.Length()) {
    nsISupports* element = mArray[aIndex];

    mArray.RemoveElementAt(aIndex);
    NS_IF_RELEASE(element);
    return true;
  }

  return false;
}

void nsCOMArray_base::RemoveElementAt(uint32_t aIndex) {
  nsISupports* element = mArray[aIndex];
  mArray.RemoveElementAt(aIndex);
  NS_IF_RELEASE(element);
}

bool nsCOMArray_base::RemoveObjectsAt(int32_t aIndex, int32_t aCount) {
  if (uint32_t(aIndex) + uint32_t(aCount) <= mArray.Length()) {
    nsTArray<nsISupports*> elementsToDestroy(aCount);
    elementsToDestroy.AppendElements(mArray.Elements() + aIndex, aCount);
    mArray.RemoveElementsAt(aIndex, aCount);
    ReleaseObjects(elementsToDestroy);
    return true;
  }

  return false;
}

void nsCOMArray_base::RemoveElementsAt(uint32_t aIndex, uint32_t aCount) {
  nsTArray<nsISupports*> elementsToDestroy(aCount);
  elementsToDestroy.AppendElements(mArray.Elements() + aIndex, aCount);
  mArray.RemoveElementsAt(aIndex, aCount);
  ReleaseObjects(elementsToDestroy);
}

// useful for destructors
void ReleaseObjects(nsTArray<nsISupports*>& aArray) {
  for (uint32_t i = 0; i < aArray.Length(); ++i) {
    NS_IF_RELEASE(aArray[i]);
  }
}

void nsCOMArray_base::Clear() {
  nsTArray<nsISupports*> objects;
  objects.SwapElements(mArray);
  ReleaseObjects(objects);
}

bool nsCOMArray_base::SetCount(int32_t aNewCount) {
  NS_ASSERTION(aNewCount >= 0, "SetCount(negative index)");
  if (aNewCount < 0) {
    return false;
  }

  int32_t count = mArray.Length();
  if (count > aNewCount) {
    RemoveObjectsAt(aNewCount, mArray.Length() - aNewCount);
  }
  mArray.SetLength(aNewCount);
  return true;
}

void nsCOMArray_base::Adopt(nsISupports** aElements, uint32_t aSize) {
  Clear();
  mArray.AppendElements(aElements, aSize);

  // Free the allocated array as well.
  free(aElements);
}

uint32_t nsCOMArray_base::Forget(nsISupports*** aElements) {
  uint32_t length = Length();
  size_t array_size = sizeof(nsISupports*) * length;
  nsISupports** array = static_cast<nsISupports**>(moz_xmalloc(array_size));
  memmove(array, Elements(), array_size);
  *aElements = array;
  // Don't Release the contained pointers; the caller of the method will
  // do this eventually.
  mArray.Clear();

  return length;
}