0022815: Missing delete operator for placement new
[occt.git] / src / NCollection / NCollection_SparseArray.hxx
1 // File:      NCollection_SparseArray.hxx
2 // Created:   23.11.06 11:12:02
3 // Author:    Andrey BETENEV
4 // Copyright: Open Cascade 2006
5
6 #ifndef NCollection_SparseArray_HeaderFile
7 #define NCollection_SparseArray_HeaderFile
8
9 #include <NCollection_SparseArrayBase.hxx>
10
11 /**
12 * Dynamically resizable sparse array of objects
13 *
14 * This class is similar to NCollection_Vector: it works like virtually
15 * unlimited array of items accessible by index; however unlike simple
16 * Vector it distinguishes items that have been set from the ones that
17 * have not been set explicitly.
18 *
19 * This class can be also seen as equivalence of
20 * NCollection_DataMap<Standard_Integer,TheItemType>
21 * with the only one practical difference: it can be much less 
22 * memory-expensive if items are small (e.g. Integer or Handle).
23
24 * The index starts from 0, i.e. should be non-negative. Memory is allocated
25 * when item is set by SetValue(). 
26 *
27 * Iterator returns only defined items; 
28 * the item can be tested for being defined by IsSet(), 
29 * and undefined by UnsetValue().
30 *
31 * The attempt to access the item that has not been set will result
32 * in OutOfRange exception in Debug mode; in Release mode this will either
33 * return null-filled object or cause access violation.
34 */
35
36 template <class TheItemType> class NCollection_SparseArray 
37                                  : public NCollection_SparseArrayBase
38 {
39 public:
40
41   //! Constructor; accepts size of blocks 
42   NCollection_SparseArray (Standard_Size theIncrement)
43     : NCollection_SparseArrayBase(sizeof(TheItemType),theIncrement)
44   { 
45   }
46
47   //! Explicit assignment operator
48   NCollection_SparseArray& Assign (const NCollection_SparseArray& theOther) 
49   {
50     this->assign (theOther);
51     return *this;
52   }
53
54   //! Exchange the data of two arrays;
55   //! can be used primarily to move contents of theOther into the new array
56   //! in a fast way (without creation of duplicated data)
57   void Exchange (NCollection_SparseArray& theOther) 
58   {
59     this->exchange (theOther);
60   }
61
62   //! Destructor
63   virtual ~NCollection_SparseArray ()
64   {
65     Clear();
66   }
67
68 public:
69   //!@name Array-like interface (in addition to inherited methods)
70   //!@{
71
72   //! Direct const access to the item 
73   const TheItemType& Value (const Standard_Integer theIndex) const 
74   {
75     return *(const TheItemType*)this->getValue(theIndex);
76   }
77
78   //! Const access to the item - operator()
79   const TheItemType& operator () (const Standard_Integer theIndex) const
80   { 
81     return Value (theIndex); 
82   }
83
84   //! Modification access to the item
85   TheItemType& ChangeValue (const Standard_Integer theIndex) 
86   {
87     return *(TheItemType*)(this->getValue (theIndex));
88   }
89
90   //! Access to the item - operator()
91   TheItemType& operator () (const Standard_Integer theIndex)
92   { 
93     return ChangeValue (theIndex); 
94   }
95   
96   //! Set a value at specified index method
97   TheItemType& SetValue (const Standard_Integer theIndex,
98                          const TheItemType&     theValue) 
99   {
100     return *(TheItemType*)this->setValue(theIndex, (Standard_Address)&theValue);
101   }
102
103   //!@}
104   
105 public:
106   //!@name DataMap-like interface
107   //!@{
108
109   //! Returns number of items in the array
110   Standard_Size Extent () const 
111   {
112     return Size();
113   }
114
115   //! Returns True if array is empty
116   Standard_Boolean IsEmpty () const 
117   {
118     return Size() == 0;
119   }
120
121   //! Direct const access to the item 
122   const TheItemType& Find (const Standard_Integer theIndex) const 
123   {
124     return *(TheItemType*)this->getValue(theIndex);
125   }
126
127   //! Modification access to the item; allocates space if 
128   //! necessary and marks the item as defined
129   TheItemType& ChangeFind (const Standard_Integer theIndex) 
130   {
131     return *(TheItemType*)(this->changeValue (theIndex));
132   }
133
134   //! Set a value as explicit method
135   TheItemType& Bind (const Standard_Integer theIndex,
136                      const TheItemType&     theValue) 
137   {
138     return SetValue(theIndex, theValue);
139   }
140   
141   //! Returns True if the item is defined
142   Standard_Boolean IsBound (const Standard_Integer theIndex) const
143   {
144     return this->HasValue(theIndex);
145   }
146   
147   //! Remove the item from array
148   Standard_Boolean UnBind (const Standard_Integer theIndex) 
149   {
150     return this->UnsetValue(theIndex);
151   }
152   
153   //!@}
154
155 public:
156   // Iterator interface
157
158   /**
159    * Implementation of type-specific const Iterator class
160    */
161   class ConstIterator : public NCollection_SparseArrayBase::Iterator
162   {
163   public:
164
165     //! Empty constructor - for later Init
166     ConstIterator () {}
167
168     //! Constructor with initialisation
169     ConstIterator (const NCollection_SparseArray& theVector) :
170       NCollection_SparseArrayBase::Iterator (&theVector) {}
171
172     //! Initialisation
173     void Init (const NCollection_SparseArray& theVector) 
174     { 
175       this->init (&theVector); 
176     } 
177
178     //! Constant value access
179     const TheItemType& Value (void) const
180     {
181       return *(const TheItemType*)this->value(); 
182     }
183
184     //! Constant value access operator
185     const TheItemType& operator () (void) const
186     {
187       return *(const TheItemType*)this->value(); 
188     }
189
190     //! Access current index with 'a-la map' interface
191     Standard_Integer Key (void) const { return Index(); }
192   };
193
194   /**
195    * Implementation of type-specific non-const Iterator class
196    */
197   class Iterator : public ConstIterator
198   {
199   public:
200
201     //! Empty constructor - for later Init
202     Iterator () {}
203
204     //! Constructor with initialisation
205     Iterator (NCollection_SparseArray& theVector) :
206       ConstIterator (theVector) {}
207
208     //! Initialisation
209     void Init (const NCollection_SparseArray& theVector) 
210     { 
211       this->init (&theVector); 
212     } 
213
214     //! Value access
215     TheItemType& ChangeValue (void)
216     {
217       return *(TheItemType*)this->value(); 
218     }
219
220     //! Value access operator
221     TheItemType& operator () (void)
222     {
223       return *(TheItemType*)this->value(); 
224     }
225
226     //! Const access operator - the same as in parent class
227     const TheItemType& operator () (void) const
228     {
229       return *(const TheItemType*)this->value(); 
230     }
231   };
232
233 private:
234   // Implementation of virtual methods providing type-specific behaviour
235
236   //! Create new item at the specified address with default constructor
237 //  virtual void createItem (Standard_Address theAddress) 
238 //  {
239 //    new (theAddress) TheItemType;
240 //  }
241   
242   //! Create new item at the specified address with copy constructor
243   //! from existing item
244   virtual void createItem (Standard_Address theAddress, Standard_Address theOther)
245   {
246     new (theAddress) TheItemType(*(const TheItemType*)theOther);
247   }
248   
249   //! Call destructor to the item at given address
250   virtual void destroyItem (Standard_Address theAddress)
251   {
252     ((TheItemType*)theAddress)->TheItemType::~TheItemType();
253   }
254
255   //! Call assignment operator to the item
256   virtual void copyItem (Standard_Address theAddress, Standard_Address theOther)
257   {
258     (*(TheItemType*)theAddress) = *(const TheItemType*)theOther;
259   }
260
261 };
262
263 #endif
264