src/StdStorage/StdStorage_BacketOfPersistent.cxx

   1 // Copyright (c) 2017 OPEN CASCADE SAS
   2 //
   3 // This file is part of Open CASCADE Technology software library.
   4 //
   5 // This library is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU Lesser General Public License version 2.1 as published
   7 // by the Free Software Foundation, with special exception defined in the file
   8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
   9 // distribution for complete text of the license and disclaimer of any warranty.
  10 //
  11 // Alternatively, this file may be used under the terms of Open CASCADE
  12 // commercial license or contractual agreement.
  13
  14 #include <StdStorage_BacketOfPersistent.hxx>
  15 #include <StdObjMgt_Persistent.hxx>
  16
  17 StdStorage_Bucket::~StdStorage_Bucket()
  18 {
  19   Standard::Free(mySpace);
  20   mySpace = 0L;
  21   mySpaceSize = 0;
  22   Clear();
  23 }
  24
  25 //=======================================================================
  26 //function : Clear
  27 //purpose  :
  28 //=======================================================================
  29 void StdStorage_Bucket::Clear()
  30 {
  31   myCurrentSpace = -1;
  32 }
  33
  34 //=======================================================================
  35 //function : Append
  36 //purpose  :
  37 //=======================================================================
  38 void StdStorage_Bucket::Append(StdObjMgt_Persistent *sp)
  39 {
  40   ++myCurrentSpace;
  41   mySpace[myCurrentSpace] = sp;
  42 }
  43
  44 //=======================================================================
  45 //function : Value
  46 //purpose  :
  47 //=======================================================================
  48 StdObjMgt_Persistent* StdStorage_Bucket::Value(const Standard_Integer theIndex) const
  49 {
  50   return mySpace[theIndex];
  51 }
  52
  53 //=======================================================================
  54 //function : Storage_BucketOfPersistent
  55 //purpose  :
  56 //=======================================================================
  57 StdStorage_BucketOfPersistent::StdStorage_BucketOfPersistent
  58 (const Standard_Integer theBucketSize, const Standard_Integer theBucketNumber)
  59 : myNumberOfBucket(1), myNumberOfBucketAllocated(theBucketNumber)
  60 , myBucketSize(theBucketSize)
  61 {
  62   myBuckets = (StdStorage_Bucket**)Standard::Allocate
  63     (sizeof(StdStorage_Bucket*) * theBucketNumber);
  64   myBuckets[0] = new StdStorage_Bucket(myBucketSize);
  65   myCurrentBucket = myBuckets[0];
  66   myLength = 0;
  67   myCurrentBucketNumber = 0;
  68 }
  69
  70 //=======================================================================
  71 //function : Clear
  72 //purpose  :
  73 //=======================================================================
  74 void StdStorage_BucketOfPersistent::Clear()
  75 {
  76   if (myBuckets) {
  77     Standard_Integer i;
  78
  79     for (i = 1; i < myNumberOfBucket; i++) delete myBuckets[i];
  80     myNumberOfBucket = 1;
  81     myCurrentBucket = myBuckets[0];
  82     myCurrentBucket->Clear();
  83     myCurrentBucketNumber = 0;
  84     myLength = 0;
  85   }
  86 }
  87
  88 StdStorage_BucketOfPersistent::~StdStorage_BucketOfPersistent()
  89 {
  90   Clear();
  91   delete myBuckets[0];
  92   Standard::Free(myBuckets);
  93   myBuckets = 0L;
  94 }
  95
  96 //=======================================================================
  97 //function : Value
  98 //purpose  :
  99 //=======================================================================
 100 StdObjMgt_Persistent* StdStorage_BucketOfPersistent::Value
 101   (const Standard_Integer theIndex)
 102 {
 103   Standard_Integer theInd, theCurrentBucketNumber, tecurrentind = theIndex - 1;
 104   theCurrentBucketNumber = tecurrentind / myBucketSize;
 105   theInd = tecurrentind - (myBucketSize * theCurrentBucketNumber);
 106
 107   return myBuckets[theCurrentBucketNumber]->mySpace[theInd];
 108 }
 109
 110 //=======================================================================
 111 //function : Append
 112 //purpose  :
 113 //=======================================================================
 114 void StdStorage_BucketOfPersistent::Append(const Handle(StdObjMgt_Persistent)& sp)
 115 {
 116   myCurrentBucket->myCurrentSpace++;
 117
 118   if (myCurrentBucket->myCurrentSpace != myBucketSize) {
 119     myLength++;
 120     myCurrentBucket->mySpace[myCurrentBucket->myCurrentSpace] = sp.operator->();
 121     return;
 122   }
 123
 124   myCurrentBucket->myCurrentSpace--;
 125   myNumberOfBucket++;
 126   myCurrentBucketNumber++;
 127
 128   if (myNumberOfBucket > myNumberOfBucketAllocated) {
 129     Standard_Size e = sizeof(StdStorage_Bucket*) * myNumberOfBucketAllocated;
 130     myBuckets = (StdStorage_Bucket**)Standard::Reallocate(myBuckets, e * 2);
 131     myNumberOfBucketAllocated *= 2;
 132   }
 133
 134   myBuckets[myCurrentBucketNumber] = new StdStorage_Bucket(myBucketSize);
 135   myCurrentBucket = myBuckets[myCurrentBucketNumber];
 136   myCurrentBucket->myCurrentSpace++;
 137   myLength++;
 138   myCurrentBucket->mySpace[myCurrentBucket->myCurrentSpace] = sp.operator->();
 139 }
 140
 141 //=======================================================================
 142 //function : Storage_BucketIterator
 143 //purpose  :
 144 //=======================================================================
 145 StdStorage_BucketIterator::StdStorage_BucketIterator
 146   (StdStorage_BucketOfPersistent* aBucketManager)
 147 {
 148   if (aBucketManager) {
 149     myBucket = aBucketManager;
 150     myCurrentBucket = myBucket->myBuckets[0];
 151     myBucketNumber = aBucketManager->myNumberOfBucket;
 152     myCurrentBucketIndex = 0;
 153     myCurrentIndex = 0;
 154     myMoreObject = Standard_True;
 155   }
 156   else myMoreObject = Standard_False;
 157 }
 158
 159 //=======================================================================
 160 //function : Reset
 161 //purpose  :
 162 //=======================================================================
 163 void StdStorage_BucketIterator::Reset()
 164 {
 165   if (myBucket) {
 166     myCurrentBucket = myBucket->myBuckets[0];
 167     myBucketNumber = myBucket->myNumberOfBucket;
 168     myCurrentIndex = 0;
 169     myCurrentBucketIndex = 0;
 170     myMoreObject = Standard_True;
 171   }
 172   else myMoreObject = Standard_False;
 173 }
 174
 175 //=======================================================================
 176 //function : Init
 177 //purpose  :
 178 //=======================================================================
 179 void StdStorage_BucketIterator::Init(StdStorage_BucketOfPersistent* aBucketManager)
 180 {
 181   if (aBucketManager) {
 182     myBucket = aBucketManager;
 183     myCurrentBucket = myBucket->myBuckets[0];
 184     myBucketNumber = aBucketManager->myNumberOfBucket;
 185     myCurrentIndex = 0;
 186     myCurrentBucketIndex = 0;
 187     myMoreObject = Standard_True;
 188   }
 189   else myMoreObject = Standard_False;
 190 }
 191
 192 //=======================================================================
 193 //function : Next
 194 //purpose  :
 195 //=======================================================================
 196 void StdStorage_BucketIterator::Next()
 197 {
 198   if (!myMoreObject) return;
 199
 200   if (myCurrentIndex < myCurrentBucket->myCurrentSpace) {
 201     myCurrentIndex++;
 202   }
 203   else {
 204     myCurrentIndex = 0;
 205     myCurrentBucketIndex++;
 206     if (myCurrentBucketIndex < myBucketNumber) {
 207       myCurrentBucket = myBucket->myBuckets[myCurrentBucketIndex];
 208     }
 209     else {
 210       myMoreObject = Standard_False;
 211     }
 212   }
 213 }