src/DBC/DBC_VArray.gxx

   1 // Copyright (c) 1998-1999 Matra Datavision
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and/or modify it under
   7 // the terms of the GNU Lesser General Public License version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 #include <Standard_OutOfRange.hxx>
  16 #include <Standard_NegativeValue.hxx>
  17 #include <Standard_NullObject.hxx>
  18 #include <Standard_NotImplemented.hxx>
  19
  20 #define BUGOCC425
  21
  22 #ifdef OBJS
  23 #include <Standard_Persistent.hxx>
  24
  25 // taille a partir de laquelle la tableau cre son propre container
  26 //
  27 #define DBC_TAILLE_PLAFOND_CREATION_SEGMENT 10000
  28
  29 #include <StandardOBJS_PersistentMacro.hxx>
  30 #include <StandardOBJS_PrimitiveTypes.hxx>
  31
  32 // just use for internal generic identifiaction of Item
  33 //
  34 static PStandard_ArrayNode DBC_tmpItem;
  35
  36 #endif
  37
  38 #ifdef OBJS
  39 #include <StandardOBJS_PersistentMacro.hxx>
  40 #endif
  41
  42 DBC_VArray::DBC_VArray() : DBC_BaseArray()
  43 {
  44 #ifdef CSFDB
  45   myData = 0L;
  46 #endif
  47 }
  48
  49 DBC_VArray::DBC_VArray(const Standard_Integer Size) : DBC_BaseArray(Size)
  50 {
  51 #ifdef BUGOCC425
  52   if(Size > 0) {
  53 #endif
  54 #ifdef CSFDB
  55     myData = (DBC_VArrayTNode*)Standard::Allocate(Size * sizeof(DBC_VArrayTNode));
  56     DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
  57     for (int i = 0; i < Size; i++) {
  58       ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
  59       ptrtmp++;
  60     }
  61
  62     //  myData = new DBC_VArrayTNode[Size];
  63 #endif
  64 #ifdef OBJS
  65     Standard_Integer i;
  66     myData = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),Size) DBC_VArrayNode[Size];
  67 #endif
  68
  69 #ifdef BUGOCC425
  70     } else {
  71 #ifdef CSFDB
  72       myData = 0L;
  73 #endif
  74 #ifdef OBJS
  75       myData = NULL;
  76 #endif
  77     }
  78 #endif
  79 }
  80
  81 DBC_VArray::DBC_VArray(const DBC_VArray& Varray) : DBC_BaseArray(Varray)
  82 {
  83 #ifdef CSFDB
  84   //myData = new DBC_VArrayTNode[mySize];
  85
  86   myData = (DBC_VArrayTNode*)Standard::Allocate(mySize * sizeof(DBC_VArrayTNode));
  87   DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
  88
  89   for(Standard_Integer i=0; i<mySize; i++) {
  90     ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
  91     ((DBC_VArrayTNode*)myData)[i] = ((DBC_VArrayTNode*)Varray.myData)[i];
  92     ptrtmp++;
  93   }
  94 #endif
  95 #ifdef OBJS
  96   myData = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),mySize) DBC_VArrayNode[mySize] ;
  97   const DBC_VArrayNode* otherArray = (DBC_VArrayNode*)Varray.myData;
  98
  99   for(Standard_Integer i=0; i<mySize; i++) {
 100     ((DBC_VArrayNode*)myData)[i].SetValue(*((Item*)(otherArray[i].Value())));
 101   }
 102 #endif
 103 }
 104
 105 // --------------------------------------------------------------------
 106 //                                   Resize
 107 // --------------------------------------------------------------------
 108 void DBC_VArray::Resize (const Standard_Integer NewSize)
 109 {
 110   Standard_NegativeValue_Raise_if((NewSize < 0),
 111                                   "DBC_VArray::Resize with a bad size");
 112
 113 #ifdef OBJY
 114   myData.resize((unsigned int)NewSize) ;
 115 #endif
 116
 117 #ifdef OBJSold
 118   Item *newData;
 119   Standard_Integer borne;
 120
 121   INTERNAL_MODE_OODB_START {
 122     os_segment *seg = Storage_CurrentContainer();
 123     newData = Standard_PersistentAllocation(DBC_tmpItem, NewSize);
 124     if ( NewSize < mySize ) {
 125       borne = NewSize;
 126     }
 127     else {
 128       borne = mySize;
 129     }
 130     for( Standard_Integer i=0; i<borne;i++ ) {
 131       newData[i] = myData[i];
 132     }
 133     if ( myData )
 134       delete (PStandard_ArrayNode*) myData;
 135     myData = newData;
 136     Storage_CurrentContainer() = seg;
 137  }
 138   INTERNAL_MODE_OODB_END;
 139 #endif
 140
 141 #ifdef OBJS
 142   if (NewSize >  mySize) {
 143     Standard_Integer i;
 144     DBC_VArrayNode* ptr = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),NewSize) DBC_VArrayNode[NewSize] ;
 145     for(i = 0; i < mySize; i++) {
 146       ((DBC_VArrayNode*)ptr)[i].SetValue(*((Item*)(((DBC_VArrayNode*)myData)[i].Value())));
 147     }
 148
 149     if (myData) delete [] myData;  // free old area.
 150     myData = ptr;
 151   }
 152 #endif
 153
 154 #ifdef CSFDB
 155   if(NewSize >  mySize || !NewSize){
 156     Standard_Integer i;
 157
 158     DBC_VArrayTNode* ptr = 0L;
 159     if(NewSize) {
 160       ptr = (DBC_VArrayTNode*)Standard::Allocate(NewSize * sizeof(DBC_VArrayTNode));
 161     }
 162
 163     DBC_VArrayTNode* ptrtmp = ptr;
 164
 165     if (mySize > 0) {
 166       if(NewSize) {
 167         for(i = 0; i < mySize; i++) {
 168           ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
 169           ptr[i].SetValue(*((Item *)((DBC_VArrayTNode*)myData)[i].Value()));
 170           ptrtmp++;
 171         }
 172       }
 173
 174       ptrtmp = (DBC_VArrayTNode*)myData;
 175       for(i = 0; i < mySize; i++) {
 176         ptrtmp->DBC_VArrayTNode::~DBC_VArrayTNode();
 177         ptrtmp++;
 178       }
 179       Standard::Free(myData);
 180     } else {
 181       for(i = 0; i < NewSize; i++) {
 182         ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
 183         ptrtmp++;
 184       }
 185     }
 186     myData = ptr;
 187   }
 188 #endif
 189
 190   mySize = NewSize;
 191 }
 192
 193 // --------------------------------------------------------------------
 194 //
 195 // --------------------------------------------------------------------
 196
 197 Item& DBC_VArray::Value( const Standard_Integer Index) const
 198 {
 199   Standard_OutOfRange_Raise_if((Index < 0 || Index >= mySize),
 200                                "Index out of range in VArray::Value");
 201 #ifdef OBJY
 202   Handle(DBC_VArrayNode) theNode = Handle(DBC_VArrayNode)::DownCast(myData.elem((unsigned int)Index));
 203   return *((Item *)theNode->Value());
 204 #endif
 205
 206 #ifdef OBJSold
 207   return myData[Index];
 208 #endif
 209
 210 #ifdef OBJS
 211   return *((Item*)(((DBC_VArrayNode*)myData)[Index].Value()));
 212 #endif
 213
 214 #ifdef CSFDB
 215   return *((Item *)((DBC_VArrayTNode*)myData)[Index].Value());
 216 #endif
 217 }
 218
 219 void DBC_VArray::Assign (const DBC_VArray& Right)
 220 {
 221 #ifdef OBJY
 222   myData.operator=(Right.myData);
 223 #endif
 224
 225 #ifdef OBJS
 226   INTERNAL_MODE_OODB_START {
 227     for(Standard_Integer i=0; i< mySize; i++){
 228       ((DBC_VArrayNode*)myData)[i].SetValue(*((Item*)(((DBC_VArrayNode*)Right.myData)[i].Value())));
 229     }
 230   }
 231   INTERNAL_MODE_OODB_END;
 232 #endif
 233
 234 #ifdef CSFDB
 235   Standard_Integer i;
 236
 237   for(i = 0; i < mySize; i++) {
 238     ((DBC_VArrayTNode*)myData)[i].SetValue(*((Item *)((DBC_VArrayTNode*)Right.myData)[i].Value()));
 239   }
 240 #endif
 241 }
 242
 243
 244 // --------------------------------------------------------------------
 245 //                                  SetValue
 246 // --------------------------------------------------------------------
 247 void DBC_VArray::SetValue(const Standard_Integer Index, const Item& Value)
 248 {
 249   Standard_OutOfRange_Raise_if((Index < 0 || Index >= mySize),
 250                                "Index out of range in VArray::SetValue");
 251 #ifdef OBJY
 252   if (myData.elem((unsigned int)Index).IsNull())
 253     {
 254       Handle(DBC_VArrayNode) theNode = new DBC_VArrayNode;
 255       myData.elem((unsigned int)Index) = theNode;
 256       theNode->SetValue(Value);
 257     }
 258   else
 259     {
 260       Handle(DBC_VArrayNode) theNode = Handle(DBC_VArrayNode)::DownCast(myData.elem((unsigned int)Index));
 261       theNode->SetValue(Value);
 262     }
 263 #endif
 264
 265 #ifdef OBJSold
 266   INTERNAL_MODE_OODB_START {
 267     myData[Index] = Value;
 268   }
 269   INTERNAL_MODE_OODB_END;
 270 #endif
 271
 272 #ifdef OBJS
 273   ((DBC_VArrayNode*)myData)[Index].SetValue(Value);
 274 #endif
 275
 276 #ifdef CSFDB
 277   ((DBC_VArrayTNode*)myData)[Index].SetValue(Value);
 278 #endif
 279 }
 280
 281 void DBC_VArray::Destroy()
 282 {
 283 #ifdef CSFDB
 284 #ifdef BUGOCC425
 285   if (myData && mySize > 0) {
 286 #else
 287   if (myData) {
 288 #endif
 289     DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
 290     for(Standard_Integer i = 0; i < mySize; i++) {
 291       ptrtmp->DBC_VArrayTNode::~DBC_VArrayTNode();
 292       ptrtmp++;
 293     }
 294     Standard::Free(myData);
 295     myData = 0L;
 296   }
 297 #endif
 298 }