#include <Standard_OutOfRange.hxx> 
#include <Standard_NegativeValue.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_NotImplemented.hxx>

#define BUGOCC425

#ifdef OBJS
#include <Standard_Persistent.hxx>

// taille a partir de laquelle la tableau cre son propre container
//
#define DBC_TAILLE_PLAFOND_CREATION_SEGMENT 10000 

#include <StandardOBJS_PersistentMacro.hxx>
#include <StandardOBJS_PrimitiveTypes.hxx>

// just use for internal generic identifiaction of Item
//
static PStandard_ArrayNode DBC_tmpItem;

#endif

#ifdef OBJS
#include <StandardOBJS_PersistentMacro.hxx>
#endif

DBC_VArray::DBC_VArray() : DBC_BaseArray()
{
#ifdef CSFDB
  myData = 0L;
#endif  
}

DBC_VArray::DBC_VArray(const Standard_Integer Size) : DBC_BaseArray(Size)
{
#ifdef BUGOCC425
  if(Size > 0) {
#endif  
#ifdef CSFDB
    myData = (DBC_VArrayTNode*)StandardCSFDB_Allocate(Size * sizeof(DBC_VArrayTNode));
    DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
    for (int i = 0; i < Size; i++) {
      ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
      ptrtmp++;
    }

    //  myData = new DBC_VArrayTNode[Size];
#endif
#ifdef OBJS
    Standard_Integer i;
    myData = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),Size) DBC_VArrayNode[Size];
#endif

#ifdef BUGOCC425
    } else {
#ifdef CSFDB
      myData = 0L;
#endif
#ifdef OBJS
      myData = NULL;
#endif
    }
#endif  
}

DBC_VArray::DBC_VArray(const DBC_VArray& Varray) : DBC_BaseArray(Varray)
{
#ifdef CSFDB
  //myData = new DBC_VArrayTNode[mySize];

  myData = (DBC_VArrayTNode*)StandardCSFDB_Allocate(mySize * sizeof(DBC_VArrayTNode));
  DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;

  for(Standard_Integer i=0; i<mySize; i++) {
    ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
    ((DBC_VArrayTNode*)myData)[i] = ((DBC_VArrayTNode*)Varray.myData)[i];
    ptrtmp++;
  }
#endif
#ifdef OBJS
  myData = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),mySize) DBC_VArrayNode[mySize] ;
  const DBC_VArrayNode* otherArray = (DBC_VArrayNode*)Varray.myData;

  for(Standard_Integer i=0; i<mySize; i++) {
    ((DBC_VArrayNode*)myData)[i].SetValue(*((Item*)(otherArray[i].Value())));
  }
#endif
}

// --------------------------------------------------------------------
//                                   Resize
// --------------------------------------------------------------------
void DBC_VArray::Resize (const Standard_Integer NewSize)
{
  Standard_NegativeValue_Raise_if((NewSize < 0),
				  "DBC_VArray::Resize with a bad size");

#ifdef OBJY
  myData.resize((unsigned int)NewSize) ;
#endif

#ifdef OBJSold
  Item *newData; 
  Standard_Integer borne;

  INTERNAL_MODE_OODB_START {
    os_segment *seg = Storage_CurrentContainer(); 
    newData = Standard_PersistentAllocation(DBC_tmpItem, NewSize);
    if ( NewSize < mySize ) {
      borne = NewSize;
    }  
    else {
      borne = mySize;
    }
    for( Standard_Integer i=0; i<borne;i++ ) {
      newData[i] = myData[i];
    }
    if ( myData )
      delete (PStandard_ArrayNode*) myData;
    myData = newData;
    Storage_CurrentContainer() = seg;
 }
  INTERNAL_MODE_OODB_END;
#endif

#ifdef OBJS
  if (NewSize >  mySize) {
    Standard_Integer i;
    DBC_VArrayNode* ptr = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),NewSize) DBC_VArrayNode[NewSize] ;
    for(i = 0; i < mySize; i++) {
      ((DBC_VArrayNode*)ptr)[i].SetValue(*((Item*)(((DBC_VArrayNode*)myData)[i].Value())));
    }

    if (myData) delete [] myData;  // free old area.
    myData = ptr;
  }
#endif 

#ifdef CSFDB
  if(NewSize >  mySize || !NewSize){
    Standard_Integer i;

    DBC_VArrayTNode* ptr = 0L;
    if(NewSize) {
      ptr = (DBC_VArrayTNode*)StandardCSFDB_Allocate(NewSize * sizeof(DBC_VArrayTNode));
    }

    DBC_VArrayTNode* ptrtmp = ptr;

    if (mySize > 0) {
      if(NewSize) {
	for(i = 0; i < mySize; i++) {
	  ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
	  ptr[i].SetValue(*((Item *)((DBC_VArrayTNode*)myData)[i].Value()));
	  ptrtmp++;
	}
      }
      
      ptrtmp = (DBC_VArrayTNode*)myData;
      for(i = 0; i < mySize; i++) {
	ptrtmp->DBC_VArrayTNode::~DBC_VArrayTNode();
	ptrtmp++;
      }
//      StandardCSFDB_Free((Standard_Address&)myData,mySize * sizeof(DBC_VArrayTNode));
      StandardCSFDB_Free((Standard_Address&)myData);
    } else {
      for(i = 0; i < NewSize; i++) {
	ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
	ptrtmp++;
      }
    }
    myData = ptr;
  } 
#endif 

  mySize = NewSize;
}

// --------------------------------------------------------------------
//
// --------------------------------------------------------------------

Item& DBC_VArray::Value( const Standard_Integer Index) const 
{
  Standard_OutOfRange_Raise_if((Index < 0 || Index >= mySize),
                               "Index out of range in VArray::Value");
#ifdef OBJY
  Handle(DBC_VArrayNode) theNode = Handle(DBC_VArrayNode)::DownCast(myData.elem((unsigned int)Index));
  return *((Item *)theNode->Value());
#endif

#ifdef OBJSold
  return myData[Index];
#endif

#ifdef OBJS
  return *((Item*)(((DBC_VArrayNode*)myData)[Index].Value()));
#endif

#ifdef CSFDB
  return *((Item *)((DBC_VArrayTNode*)myData)[Index].Value());
#endif
}

void DBC_VArray::Assign (const DBC_VArray& Right) 
{
#ifdef OBJY
  myData.operator=(Right.myData);
#endif

#ifdef OBJS
  INTERNAL_MODE_OODB_START {
    for(Standard_Integer i=0; i< mySize; i++){
      ((DBC_VArrayNode*)myData)[i].SetValue(*((Item*)(((DBC_VArrayNode*)Right.myData)[i].Value())));
    }
  }
  INTERNAL_MODE_OODB_END;
#endif

#ifdef CSFDB
  Standard_Integer i;

  for(i = 0; i < mySize; i++) {
    ((DBC_VArrayTNode*)myData)[i].SetValue(*((Item *)((DBC_VArrayTNode*)Right.myData)[i].Value()));
  }
#endif
}


// --------------------------------------------------------------------
//                                  SetValue
// --------------------------------------------------------------------
void DBC_VArray::SetValue(const Standard_Integer Index, const Item& Value)
{
  Standard_OutOfRange_Raise_if((Index < 0 || Index >= mySize),
                               "Index out of range in VArray::SetValue");
#ifdef OBJY
  if (myData.elem((unsigned int)Index).IsNull())
    {
      Handle(DBC_VArrayNode) theNode = new DBC_VArrayNode;
      myData.elem((unsigned int)Index) = theNode;
      theNode->SetValue(Value);
    }
  else
    {
      Handle(DBC_VArrayNode) theNode = Handle(DBC_VArrayNode)::DownCast(myData.elem((unsigned int)Index));
      theNode->SetValue(Value);
    }
#endif 

#ifdef OBJSold
  INTERNAL_MODE_OODB_START {
    myData[Index] = Value;
  }
  INTERNAL_MODE_OODB_END;
#endif

#ifdef OBJS
  ((DBC_VArrayNode*)myData)[Index].SetValue(Value);
#endif

#ifdef CSFDB
  ((DBC_VArrayTNode*)myData)[Index].SetValue(Value);
#endif
}

void DBC_VArray::Destroy()
{
#ifdef CSFDB
#ifdef BUGOCC425
  if (myData && mySize > 0) {
#else
  if (myData) {
#endif 
    DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
    for(Standard_Integer i = 0; i < mySize; i++) {
      ptrtmp->DBC_VArrayTNode::~DBC_VArrayTNode();
      ptrtmp++;
    }
//    StandardCSFDB_Free((Standard_Address&)myData,mySize * sizeof(DBC_VArrayTNode));
    StandardCSFDB_Free((Standard_Address&)myData);
    myData = 0L;
  }
#endif	
}