/*

* Copyright (c) 2000 - 2001 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include "nw_adt_segmentedvectori.h"

#include "BrsrStatusCodes.h"

/* ------------------------------------------------------------------------- *

   class definition

 * ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

const

NW_ADT_SegmentedVector_Class_t NW_ADT_SegmentedVector_Class = {

  { /* NW_Object_Core            */

    /* super                     */ &NW_ADT_DynamicVector_Class,

    /* queryInterface            */ _NW_Object_Base_QueryInterface

  },

  { /* NW_Object_Base            */

    /* interfaceList             */ NULL

  },

  { /* NW_Object_Dynamic         */

    /* instanceSize		 */ sizeof (NW_ADT_SegmentedVector_t),

    /* construct		 */ _NW_ADT_SegmentedVector_Construct,

    /* destruct			 */ _NW_ADT_SegmentedVector_Destruct

  },

  { /* NW_ADT_Vector		 */

    /* getElementSize            */ _NW_ADT_DynamicVector_GetElementSize,

    /* getSize                   */ _NW_ADT_DynamicVector_GetSize,

    /* addressAt		 */ _NW_ADT_SegmentedVector_AddressAt

  },

  { /* NW_ADT_DynamicVector      */

    /* resizeCapacity            */ _NW_ADT_SegmentedVector_ResizeCapacity,

    /* moveElements		 */ _NW_ADT_SegmentedVector_MoveElements,

    /* clear                     */ _NW_ADT_DynamicVector_Clear

  },

  { /* NW_ADT_SegmentedVector	 */

    /* segmentListIncrement	 */ 4,

    /* allocateSegment           */ _NW_ADT_SegmentedVector_AllocateSegment

  },

};

/* ------------------------------------------------------------------------- *

   virtual methods

 * ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

TBrowserStatusCode

_NW_ADT_SegmentedVector_Construct (NW_Object_Dynamic_t* dynamicObject,

                                   va_list* argp)

{

  NW_ADT_SegmentedVector_t* thisObj;

  TBrowserStatusCode status;

  /* for convenience */

  thisObj = NW_ADT_SegmentedVectorOf (dynamicObject);

  /* invoke our superclass constructor */

  status = _NW_ADT_DynamicVector_Construct (dynamicObject, argp);

  if (status != KBrsrSuccess) {

    return status;

  }

  /* initialize the object */

  thisObj->segmentSize = (NW_ADT_Vector_Metric_t) va_arg (*argp, NW_Uint32);

  thisObj->segmentListSize =

    NW_ADT_SegmentedVector_GetSegmentListIncrement (thisObj);

  thisObj->segmentList = (NW_Uint8**)

    NW_Mem_Malloc (thisObj->segmentListSize * sizeof (*thisObj->segmentList));

  if (thisObj->segmentList == NULL) {

    return KBrsrOutOfMemory;

  }

  /* successful completion */

  return KBrsrSuccess;

}

/* ------------------------------------------------------------------------- */

void

_NW_ADT_SegmentedVector_Destruct (NW_Object_Dynamic_t* dynamicObject)

{

  NW_ADT_SegmentedVector_t* thisObj;

  NW_ADT_Vector_Metric_t index;

  /* for convenience */

  thisObj = NW_ADT_SegmentedVectorOf (dynamicObject);

  /* release our resources */

  for (index = 0; index < thisObj->numSegments; index++) {

    NW_Mem_Free (thisObj->segmentList[index]);

  }

  NW_Mem_Free (thisObj->segmentList);

}

/* ------------------------------------------------------------------------- */

TBrowserStatusCode

_NW_ADT_SegmentedVector_ResizeCapacity (NW_ADT_DynamicVector_t* dynamicVector,

                                        NW_ADT_Vector_Metric_t capacityNeeded)

{

  NW_ADT_SegmentedVector_t* thisObj;

  NW_ADT_Vector_Metric_t newNumSegments;

  NW_ADT_Vector_Metric_t newSegmentListSize;

  NW_ADT_Vector_Metric_t segmentListIncrement;

  NW_Uint8** newSegmentList;

  /* for convenience */

  thisObj = NW_ADT_SegmentedVectorOf (dynamicVector);

  /* calculate the new segmentList size */

  newNumSegments =

    (NW_ADT_Vector_Metric_t) ((capacityNeeded - 1) / thisObj->segmentSize + 1);

  segmentListIncrement = NW_ADT_SegmentedVector_GetSegmentListIncrement (thisObj);

  newSegmentListSize = (NW_ADT_Vector_Metric_t)

    (((newNumSegments - 1) / segmentListIncrement + 1) * segmentListIncrement);

  /* if we are shrinking the array, we must first deallocate all the segments

     that will be obsolete */

  while (thisObj->numSegments > newNumSegments) {

    NW_Mem_Free (thisObj->segmentList[--thisObj->numSegments]);

  }

  dynamicVector->capacity =

    (NW_ADT_Vector_Metric_t) (thisObj->numSegments * thisObj->segmentSize);

  /* allocate the new segmentList and copy the old segmentList entries into the

     new */

  newSegmentList =

    (NW_Uint8**) NW_Mem_Malloc (newSegmentListSize * sizeof (*newSegmentList));

  if (newSegmentList == NULL) {

    return KBrsrOutOfMemory; 

  }

  (void) NW_Mem_memcpy (newSegmentList, thisObj->segmentList,

                        thisObj->numSegments * sizeof (*newSegmentList));

  /* free the old segmentList and install the new */

  NW_Mem_Free (thisObj->segmentList);

  thisObj->segmentList = newSegmentList;

  thisObj->segmentListSize = newSegmentListSize;

  /* if we are growing the array we need to allocate the new segments */

  while (thisObj->numSegments < newNumSegments) {

    thisObj->segmentList[thisObj->numSegments] =

      NW_ADT_SegmentedVector_AllocateSegment(thisObj);

    if (thisObj->segmentList[thisObj->numSegments++] == NULL) {

      thisObj->numSegments -= 1;

      return KBrsrFailure; /* TODO: return more descriptive error */ 

    }

  }

  dynamicVector->capacity =

    (NW_ADT_Vector_Metric_t) (thisObj->numSegments * thisObj->segmentSize);

  /* successful completion */

  return KBrsrSuccess;

}

/* ------------------------------------------------------------------------- */

NW_Uint8*

_NW_ADT_SegmentedVector_AddressAt (const NW_ADT_Vector_t* vector,

                                   NW_ADT_Vector_Metric_t index)

{

  NW_ADT_SegmentedVector_t* thisObj;

  NW_ADT_Vector_Metric_t segmentIndex;

  /* cast the object into our class */

  thisObj = (NW_ADT_SegmentedVector_t*) vector;

  /* determine the segment index and return the offset into that segment */

  segmentIndex =

    (NW_ADT_Vector_Metric_t) (index / thisObj->segmentSize);

  return

    (NW_Uint8*) thisObj->segmentList[segmentIndex]

    + (index % thisObj->segmentSize)

    * NW_ADT_DynamicVectorOf (vector)->elementSize;

}

/* ------------------------------------------------------------------------- */

TBrowserStatusCode

_NW_ADT_SegmentedVector_MoveElements (NW_ADT_DynamicVector_t* dynamicVector,

                                      NW_ADT_Vector_Metric_t srcIndex,

                                      NW_ADT_Vector_Metric_t dstIndex)

{

  NW_Int32 sizeDelta;

  NW_ADT_Vector_Metric_t numElements;

  NW_Int32 index;

  /* */

  if (dstIndex > srcIndex) {

    sizeDelta = dstIndex - srcIndex;

  } else {

    sizeDelta = - (NW_Int32) (srcIndex - dstIndex);

  }

  if (dynamicVector->size + sizeDelta > dynamicVector->capacity) {

    TBrowserStatusCode status;

    status =

      NW_ADT_DynamicVector_ResizeCapacity (dynamicVector,

                                           (NW_ADT_Vector_Metric_t)

                                           (dynamicVector->size + sizeDelta));

    if (status != KBrsrSuccess) {

      return status;

    }

  }

  /* now do the actual move */

  /* TODO: this is a very inefficient way of moving the data, we will probably

     need to implement a block move capability */

  numElements = (NW_ADT_Vector_Metric_t) (dynamicVector->size - srcIndex);

  if (srcIndex > dstIndex) {

    for (index = 0; index < numElements; index++) {

      (void) NW_Mem_memcpy (NW_ADT_Vector_AddressAt (NW_ADT_VectorOf (dynamicVector),

                                                     (NW_ADT_Vector_Metric_t) (dstIndex + index)),

                            NW_ADT_Vector_AddressAt (NW_ADT_VectorOf (dynamicVector),

                                                     (NW_ADT_Vector_Metric_t) (srcIndex + index)),

                            dynamicVector->elementSize);

    }

  } else {

    for (index = numElements - 1; index >= 0; index--) {

      (void) NW_Mem_memcpy (NW_ADT_Vector_AddressAt (NW_ADT_VectorOf (dynamicVector),

                                                     (NW_ADT_Vector_Metric_t) (dstIndex + index)),

                            NW_ADT_Vector_AddressAt (NW_ADT_VectorOf (dynamicVector),

                                                     (NW_ADT_Vector_Metric_t) (srcIndex + index)),

                            dynamicVector->elementSize);

    }

  }

  /* successful completion */

  return KBrsrSuccess;

}

/* ------------------------------------------------------------------------- */

NW_Uint8*

_NW_ADT_SegmentedVector_AllocateSegment (NW_ADT_SegmentedVector_t* thisObj)

{

  return (NW_Uint8*) NW_Mem_Malloc (thisObj->segmentSize * thisObj->super.elementSize);

}

/* ------------------------------------------------------------------------- *

   convenience functions

 * ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

NW_ADT_SegmentedVector_t*

NW_ADT_SegmentedVector_New (NW_ADT_Vector_Metric_t elementSize,

                            NW_ADT_Vector_Metric_t segmentSize)

{

  return (NW_ADT_SegmentedVector_t*)

    NW_Object_New (&NW_ADT_SegmentedVector_Class, (NW_Uint32) elementSize, (NW_Uint32)0,

                   (NW_Uint32)segmentSize);

}