6da8f74385de40521eeed5052d223e54b0cdd5f1
[occt.git] / src / NCollection / NCollection_BaseVector.hxx
1 // File:      NCollection_BaseVector.hxx
2 // Created:   24.04.02 09:41:39
3 // Author:    Alexander GRIGORIEV
4 // Copyright: Open Cascade 2002
5
6
7 #ifndef NCollection_BaseVector_HeaderFile
8 #define NCollection_BaseVector_HeaderFile
9
10 #include <Standard_TypeDef.hxx>
11 #include <stddef.h>
12
13 #if !defined No_Exception && !defined No_Standard_OutOfRange
14 #include <Standard_OutOfRange.hxx>
15 #endif
16
17 #ifdef WNT
18 #pragma warning(push, 1)
19 #pragma warning(disable:4355)
20 #endif
21
22 /**
23  *  Class NCollection_BaseVector - base for generic vector
24  */
25 class NCollection_BaseVector 
26 {
27  public:
28   // ------------ Class MemBlock ------------
29   class MemBlock {
30   protected:
31     MemBlock ()
32       : myFirstInd(0), myLength(0), mySize(0), myData(0L) {}
33     MemBlock (const Standard_Integer theFirstInd,
34               const Standard_Integer theLength)
35       : myFirstInd(theFirstInd), myLength(0), mySize(theLength), myData(0L) {}
36     virtual             ~MemBlock () {}
37     virtual void        Reinit     (const Standard_Integer,
38                                     const size_t) {}
39     Standard_Integer    FirstIndex () const     { return myFirstInd; }
40     size_t              Size       () const     { return mySize; }
41   public:
42     void                SetLength  (const size_t theLen)
43                                                 { myLength = theLen; }
44     size_t              Length     () const     { return myLength; }
45     void *              Find       (const Standard_Integer theInd,
46                                     const size_t           theSize) const
47                                     { return ((char *) myData)+theInd*theSize;}
48     Standard_EXPORT Standard_Integer
49                         GetIndexV  (void * theItem, const size_t theSz) const;
50   protected:
51     Standard_Integer             myFirstInd;
52     size_t                       myLength;
53     size_t                       mySize;
54     void                         * myData;
55     friend class NCollection_BaseVector;
56   };
57
58   class Iterator {
59   protected:
60     Iterator () :
61       myICurBlock (0), myIEndBlock (0), myCurIndex (0), myEndIndex (0) {}
62     Iterator (const NCollection_BaseVector& theVector) { InitV (theVector); }
63     Iterator (const Iterator& theVector)               { CopyV (theVector); }
64     Standard_EXPORT void InitV (const NCollection_BaseVector& theVector);
65     Standard_EXPORT void CopyV (const Iterator&);
66     Standard_Boolean     MoreV () const
67         { return (myICurBlock < myIEndBlock || myCurIndex < myEndIndex); }
68     void                 NextV ()
69         { if (++myCurIndex >= myVector -> myData[myICurBlock].Length() &&
70               myICurBlock < myIEndBlock)
71           { ++myICurBlock; myCurIndex = 0; } }
72     const MemBlock *     CurBlockV () const
73         { return &myVector -> myData[myICurBlock]; }
74
75     const NCollection_BaseVector * myVector;   // the Master vector
76     size_t                       myICurBlock;  // # of the current block
77     size_t                       myIEndBlock;
78     size_t                       myCurIndex;   // Index in the current block
79     size_t                       myEndIndex;
80   };
81
82  protected:
83   // ------------ Block initializer ---------
84   typedef MemBlock * (* FuncPtrDataInit) (const NCollection_BaseVector&,
85                                           const Standard_Integer aCapacity,
86                                           const void             * aSource,
87                                           const Standard_Integer aSize);
88   typedef void (* FuncPtrDataFree)       (const NCollection_BaseVector&,
89                                           MemBlock *);
90
91   friend class Iterator;
92
93   // ---------- PROTECTED METHODS ----------
94
95   //! Empty constructor
96   NCollection_BaseVector (const size_t           theSize,
97                           const Standard_Integer theInc,
98                           FuncPtrDataInit        theDataInit,
99                           FuncPtrDataFree        theDataFree)
100      : myItemSize  (theSize),
101        myIncrement (theInc),
102        myLength    (0),
103        myCapacity  (theInc),
104        myNBlocks   (0),
105        myData      (theDataInit (* this, myCapacity, NULL, 0)),
106        myDataInit  (theDataInit),
107        myDataFree  (theDataFree)
108   {
109 //    myData = (MemBlock *) new char [myCapacity * sizeof(MemBlock)];
110 //    for (Standard_Integer i = 0; i < myCapacity; i++)
111 //      new (&myData[i]) MemBlock;
112   }
113
114   //! Copy constructor
115   NCollection_BaseVector (const NCollection_BaseVector& theOther,
116                           FuncPtrDataInit               theDataInit,
117                           FuncPtrDataFree               theDataFree)
118     : myItemSize  (theOther.myItemSize),
119       myIncrement (theOther.myIncrement),
120       myLength    (theOther.Length()),
121       myCapacity  (theOther.myIncrement+theOther.Length()/theOther.myIncrement),
122       myNBlocks   (1 + (theOther.Length() - 1)/theOther.myIncrement),
123       myData      (theDataInit (* this, myCapacity, NULL, 0)),
124       myDataInit  (theDataInit),
125       myDataFree  (theDataFree)  {}
126
127   //! Destructor
128   Standard_EXPORT ~NCollection_BaseVector ();
129
130   //! Operator =
131   Standard_EXPORT NCollection_BaseVector& operator =
132                                  (const NCollection_BaseVector&);
133
134   //! ExpandV: returns pointer to memory where to put the new item
135   Standard_EXPORT void * ExpandV (const Standard_Integer theIndex);
136
137   //! Find: locate the memory holding the desired value
138   inline          void * Find    (const Standard_Integer theIndex) const;
139
140  public:
141   //! Total number of items
142   Standard_Integer      Length  () const      { return myLength; }
143
144   //! Empty the vector of its objects
145   Standard_EXPORT void  Clear   ();
146
147  protected:
148   // ---------- PRIVATE FIELDS ----------
149   size_t                myItemSize;
150   Standard_Integer      myIncrement;
151   Standard_Integer      myLength;
152   Standard_Integer      myCapacity;
153   Standard_Integer      myNBlocks;
154   MemBlock              * myData;
155   FuncPtrDataInit       myDataInit;
156   FuncPtrDataFree       myDataFree;
157 };
158
159 //=======================================================================
160 //function : Find
161 //purpose  : locate the memory holding the desired value
162 //=======================================================================
163
164 inline void * NCollection_BaseVector::Find
165                                         (const Standard_Integer theIndex) const
166 {
167 #if !defined No_Exception && !defined No_Standard_OutOfRange
168   if (theIndex < 0 || theIndex >= myLength)
169     Standard_OutOfRange::Raise ("NCollection_BaseVector::Find");
170 #endif
171   const Standard_Integer aBlock = theIndex / myIncrement;
172   return myData[aBlock].Find (theIndex - aBlock * myIncrement, myItemSize);
173 }
174
175 #ifdef WNT
176 #pragma warning(pop)
177 #endif
178
179 #endif