/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 "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 *e) {
        new (static_cast<void *>(e)) E();
    }
    // Invoke the copy-constructor in place.
    template<class A>
    static inline void Construct(E *e, const A &arg) {
        new (static_cast<void *>(e)) E(arg);
    }
    // Invoke the destructor in place.
    static inline void Destruct(E *e) {
        e->~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);
}

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]);
}

bool
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);
  // XXX make this return void
  return true;
}

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;
}

size_t
nsCOMArray_base::SizeOfExcludingThis(
                   nsBaseArraySizeOfElementIncludingThisFunc aSizeOfElementIncludingThis,
                   mozilla::MallocSizeOf aMallocSizeOf, void* aData) const
{
    size_t n = mArray.SizeOfExcludingThis(aMallocSizeOf);

    if (aSizeOfElementIncludingThis)
        for (uint32_t index = 0; index < mArray.Length(); index++)
            n += aSizeOfElementIncludingThis(mArray[index], aMallocSizeOf, aData);

    return n;
}


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

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

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

    return length;
}