/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: osn vector pointer implementation.
*
*/

#if defined(__GNUC__)
#include <stdlib.h>
#include <string.h>
#else
#include <libc/string.h>
#endif

#include <osn/alfptrvectorimpl.h>
#include <stdexcept>

namespace osncore
    {

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT AlfPtrVectorImpl::AlfPtrVectorImpl(IDeleter& aDeleter)
    : mdata(0), msize(0), mcount(0), mDeleter(aDeleter)
    {
    }

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT AlfPtrVectorImpl::AlfPtrVectorImpl(uint aSize, IDeleter& aDeleter): 
    mdata(0),
    msize(aSize), 
    mcount(0), mDeleter(aDeleter)
    {
    mdata = (void **)malloc(aSize * sizeof(void *));
    if(!mdata)
        {
        throw std::bad_alloc();    
        }
    memset(mdata, 0, aSize * sizeof(void *));
    }


// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT AlfPtrVectorImpl::~AlfPtrVectorImpl()
{
    free(mdata);
}

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT void AlfPtrVectorImpl::clear(bool aDelItems)
    {
    mcount = 0;
    
    if (aDelItems) 
        {
    	for (uint i = 0; i < msize; ++i) 
    	    {
            void *item = mdata[i];
    	    if (item) 
    	        {
    		    mDeleter.deleteItem(item);
    	        }
    	}
	}
    free(mdata);
    mdata = 0;
    msize = 0;    
    }

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT bool AlfPtrVectorImpl::remove(uint aCount, bool aDelItems)
{
    if (aCount >= msize) {
        return false;
    }
    
    void *item = mdata[aCount];

    --mcount;

    //Move all the items below the deleted items up by 1 index
    for(uint i =aCount; i< msize && msize > aCount;++i)
    {
    	mdata[i]= mdata[i+1];
    }

    //Reset the items to null - from index = count to the size  after the shuffling.
    for(uint i=mcount;i<msize;++i)
    {
    	mdata[i] = 0;
    }

    // Array is now in good shape. Can call out of the class via destructors
    if (item) {
        if (aDelItems) {
            mDeleter.deleteItem(item);
        }
    }     
    return true;
}

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT bool AlfPtrVectorImpl::resize(uint aSize, bool aDelItems)
{
    uint oldSize = msize;
    
    for (uint i = aSize; i < oldSize; ++i) {
        void *item = mdata[i];
        if (item) {
            --mcount;
        }
    }
    
    for (uint i = aSize; i < oldSize; ++i) {
    	void *item = mdata[i];
    	if (item) {
        if (aDelItems) {
           mDeleter.deleteItem(item);
        	}
    	}
    }
    
    void** data = (void **)realloc(mdata, aSize * sizeof(void *));
    if(!data)
        {
        throw std::bad_alloc();    
        }
    mdata = data;    
    msize = aSize;    

    if (aSize > oldSize) 
    {
        memset(&mdata[oldSize], 0, (aSize - oldSize) * sizeof(void *));
    }
    return true;
}

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT bool AlfPtrVectorImpl::insert(uint aCount, void *aItem, bool /*aDelItems*/)
{
	uint iNum=0;
	//If there are no items and  the position to add > 0 or <0 then  return false. Do not do anything
	//if the Index is greater than the current count then Do not do anything
	//if aCount== count There will be scope to add at the most one item
	if((aCount > mcount) || (mcount==0 && aCount >iNum)||(mcount==0 && aCount < iNum))
           {
    	   return false;
           } 

	
	if(mcount>=msize)
    	{
		// 1. Let's increase the count
		int oldSize = msize;	
	    msize++;
	
		// 2. Re-allocate memeory area 	
    	void** tmp = (void **)realloc(mdata, msize * sizeof(void *));
	    if(!tmp)
	        {
	        msize--;
	        throw std::bad_alloc();    
	        }
	    mdata = tmp;    
	   	memset(&mdata[oldSize], 0, (msize- oldSize) * sizeof(void *));
        }

	    //Now move	elements from nth element to the last element by 1 position
	    //Move all
	    if(aCount < mcount)
	        { 
		    for(int i =mcount;i > aCount; --i)
		        {
		    	mdata[i]= mdata[i-1];
		        }    
		    }
	    //Now assign the new element at this position and increment the count	    	    
	    
	    mdata[aCount] = aItem;
	    if (aItem) 
	    {
	        ++mcount;
	    }
	        
    return true;
}

// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
//
OSN_EXPORT int AlfPtrVectorImpl::findRef(void *aItem)
{
    for (unsigned i = 0; i < mcount; i++) {
        if (mdata[i] == aItem) {
            return i;
        }
    }
    
    return -1;
}



} //osncore