0022815: Missing delete operator for placement new
[occt.git] / src / NCollection / NCollection_Array1.hxx
1 // File:        NCollection_Array1.hxx
2 // Created:     15.04.02 17:05:16
3 // Author:      Alexander Kartomin (akm)
4 //              <a-kartomin@opencascade.com>
5 // Copyright:   Open Cascade 2002
6
7 #ifndef NCollection_Array1_HeaderFile
8 #define NCollection_Array1_HeaderFile
9
10 #ifndef No_Exception
11 #include <Standard_DimensionMismatch.hxx>
12 #include <Standard_OutOfMemory.hxx>
13 #include <Standard_OutOfRange.hxx>
14 #endif
15
16 #include <NCollection_BaseCollection.hxx>
17
18 // *********************************************** Template for Array1 class
19
20 /**
21 * Purpose:     The class Array1 represents unidimensional arrays 
22 *              of fixed size known at run time. 
23 *              The range of the index is user defined.
24 *              An array1 can be constructed with a "C array".
25 *              This functionality is useful to call methods expecting
26 *              an Array1. It allows to carry the bounds inside the arrays.
27 *              
28 * Examples:    Item tab[100]; //  An example with a C array
29 *              Array1OfItem ttab (tab[0],1,100);
30 *              
31 *              Array1OfItem tttab (ttab(10),10,20); // a slice of ttab
32 *              
33 *              If you want to reindex an array from 1 to Length do :
34 *              
35 *              Array1 tab1(tab(tab.Lower()),1,tab.Length());
36 *                          
37 * Warning:     Programs client of such a class must be independant
38 *              of the range of the first element. Then, a C++ for
39 *              loop must be written like this
40 *              
41 *              for (i = A.Lower(); i <= A.Upper(); i++)
42 *              
43 * Changes:     In  comparison  to  TCollection  the  flag  isAllocated  was
44 *              renamed into myDeletable (alike in  the Array2).  For naming
45 *              compatibility the method IsAllocated remained in class along
46 *              with IsDeletable.
47 */              
48 template <class TheItemType> class NCollection_Array1
49   : public NCollection_BaseCollection<TheItemType>
50 {
51
52  public:
53   //! Implementation of the Iterator interface.
54   class Iterator : public NCollection_BaseCollection<TheItemType>::Iterator
55   {
56   public:
57     //! Empty constructor - for later Init
58     Iterator  (void) :
59       myCurrent (0),
60       myArray   (NULL) {}
61     //! Constructor with initialisation
62     Iterator  (const NCollection_Array1& theArray) :
63       myCurrent (theArray.Lower()),
64       myArray   ((NCollection_Array1 *) &theArray) {}
65     //! Initialisation
66     void Init (const NCollection_Array1& theArray)
67     { 
68       myCurrent = theArray.Lower();
69       myArray   = (NCollection_Array1 *) &theArray; 
70     }
71     //! Check end
72     virtual Standard_Boolean More (void) const
73     { return (myCurrent<=myArray->Upper()); }
74     //! Make step
75     virtual void Next (void)         
76     { myCurrent++; }
77     //! Constant value access
78     virtual const TheItemType& Value (void) const
79     { return myArray->Value(myCurrent); }
80     //! Variable value access
81     virtual TheItemType& ChangeValue (void) const 
82     { return myArray->ChangeValue(myCurrent); }
83   private:
84     Standard_Integer    myCurrent; //!< Index of the current item
85     NCollection_Array1* myArray;   //!< Pointer to the array being iterated
86   }; // End of the nested class Iterator
87
88  public:
89   // ---------- PUBLIC METHODS ------------
90
91   //! Constructor
92   NCollection_Array1(const Standard_Integer theLower,
93                      const Standard_Integer theUpper) :
94                 NCollection_BaseCollection<TheItemType>  (),
95                 myLowerBound                             (theLower),
96                 myUpperBound                             (theUpper),
97                 myDeletable                              (Standard_True)
98   {
99 #if !defined No_Exception && !defined No_Standard_RangeError
100     if (theUpper < theLower)
101       Standard_RangeError::Raise ("NCollection_Array1::Create");
102 #endif
103     TheItemType* pBegin = new TheItemType[Length()];
104 #if !defined No_Exception && !defined No_Standard_OutOfMemory
105     if (!pBegin)
106       Standard_OutOfMemory::Raise ("NCollection_Array1 : Allocation failed");
107 #endif
108
109     myData = pBegin - theLower;
110   }
111
112   //! Copy constructor 
113   NCollection_Array1 (const NCollection_Array1& theOther) :
114     NCollection_BaseCollection<TheItemType>     (),
115     myLowerBound                                (theOther.Lower()),
116     myUpperBound                                (theOther.Upper()),
117     myDeletable                                 (Standard_True)
118   {
119     TheItemType* pBegin = new TheItemType[Length()];
120 #if !defined No_Exception && !defined No_Standard_OutOfMemory
121     if (!pBegin)
122       Standard_OutOfMemory::Raise ("NCollection_Array1 : Allocation failed");
123 #endif
124     myData = pBegin - myLowerBound;
125
126     *this = theOther;
127   }
128
129   //! C array-based constructor
130   NCollection_Array1 (const TheItemType& theBegin,
131                       const Standard_Integer theLower,
132                       const Standard_Integer theUpper) :
133     NCollection_BaseCollection<TheItemType>     (),
134     myLowerBound                                (theLower),
135     myUpperBound                                (theUpper),
136     myDeletable                                 (Standard_False)
137   {
138 #if !defined No_Exception && !defined No_Standard_RangeError
139     if (theUpper < theLower)
140       Standard_RangeError::Raise ("NCollection_Array1::Array1");
141 #endif
142     myData = (TheItemType *) &theBegin - theLower; 
143   }
144
145   //! Initialise the items with theValue
146   void Init (const TheItemType& theValue) 
147   {
148     TheItemType *pCur = &myData[myLowerBound], *pEnd=&myData[myUpperBound];
149     for(; pCur <= pEnd; pCur++)
150       *pCur = (TheItemType&) theValue;
151   }
152
153   //! Size query
154   virtual Standard_Integer Size (void) const
155   { return Length(); }
156   //! Length query (the same)
157   Standard_Integer Length (void) const
158   { return (myUpperBound-myLowerBound+1); }
159
160   //! Lower bound
161   Standard_Integer Lower (void) const
162   { return myLowerBound; }
163   //! Upper bound
164   Standard_Integer Upper (void) const
165   { return myUpperBound; }
166
167   //! myDeletable flag
168   Standard_Boolean IsDeletable (void) const
169   { return myDeletable; }
170
171   //! IsAllocated flag - for naming compatibility
172   Standard_Boolean IsAllocated (void) const
173   { return myDeletable; }
174
175   //! Assign (any collection to this array)
176   // Copies items from the other collection into the allocated
177   // storage. Raises an exception when sizes differ.
178   virtual void Assign (const NCollection_BaseCollection<TheItemType>& theOther)
179   {
180     if (&theOther == this)
181       return;
182 #if !defined No_Exception && !defined No_Standard_DimensionMismatch
183     if (Length() != theOther.Size())
184       Standard_DimensionMismatch::Raise ("NCollection_Array1::Assign");
185 #endif
186     TYPENAME NCollection_BaseCollection<TheItemType>::Iterator& anIter2 = 
187       theOther.CreateIterator();
188     TheItemType * const pEndItem = &myData[myUpperBound];
189     for (TheItemType * pItem = &myData[myLowerBound];
190          pItem <= pEndItem;   anIter2.Next())
191       * pItem ++ = anIter2.Value();
192   }
193
194   //! operator= (array to array)
195   NCollection_Array1& operator= (const NCollection_Array1& theOther)
196   {
197     if (&theOther == this)
198       return *this;
199 #if !defined No_Exception && !defined No_Standard_DimensionMismatch
200     if (Length() != theOther.Length())
201       Standard_DimensionMismatch::Raise ("NCollection_Array1::operator=");
202 #endif
203     TheItemType * pMyItem        = &myData[myLowerBound];
204     TheItemType * const pEndItem = &(theOther.myData)[theOther.myUpperBound];
205     TheItemType * pItem          = &(theOther.myData)[theOther.myLowerBound];
206     while (pItem <= pEndItem) * pMyItem ++ = * pItem ++;
207     return *this; 
208   }
209
210   //! Constant value access
211   const TheItemType& Value (const Standard_Integer theIndex) const
212   {
213 #if !defined No_Exception && !defined No_Standard_OutOfRange
214     if (theIndex < myLowerBound || theIndex > myUpperBound)
215       Standard_OutOfRange::Raise ("NCollection_Array1::Value");
216 #endif
217     return myData[theIndex];
218   }
219
220   //! operator() - alias to Value
221   const TheItemType& operator() (const Standard_Integer theIndex) const
222   { return Value (theIndex); }
223
224   //! Variable value access
225   TheItemType& ChangeValue (const Standard_Integer theIndex)
226   {
227 #if !defined No_Exception && !defined No_Standard_OutOfRange
228     if (theIndex < myLowerBound || theIndex > myUpperBound)
229       Standard_OutOfRange::Raise ("NCollection_Array1::ChangeValue");
230 #endif
231     return myData[theIndex];
232   }
233
234   //! operator() - alias to ChangeValue
235   TheItemType& operator() (const Standard_Integer theIndex)
236   { return ChangeValue (theIndex); }
237
238   //! Set value 
239   void SetValue (const Standard_Integer theIndex,
240                  const TheItemType&     theItem)
241   {
242 #if !defined No_Exception && !defined No_Standard_OutOfRange
243     if (theIndex < myLowerBound || theIndex > myUpperBound)
244       Standard_OutOfRange::Raise ("NCollection_Array1::SetValue");
245 #endif
246     myData[theIndex] = theItem;
247   }
248
249   //! Destructor - releases the memory
250   ~NCollection_Array1 (void)
251   { if (myDeletable) delete [] &(myData[myLowerBound]); }
252
253  private:
254   // ----------- PRIVATE METHODS -----------
255
256   // ******** Creates Iterator for use on BaseCollection
257   virtual
258   TYPENAME NCollection_BaseCollection<TheItemType>::Iterator& 
259                         CreateIterator(void) const
260   { return *(new (this->IterAllocator()) Iterator(*this)); }
261
262  protected:
263   // ---------- PROTECTED FIELDS -----------
264   Standard_Integer     myLowerBound;
265   Standard_Integer     myUpperBound;
266   Standard_Boolean     myDeletable; //!< Flag showing who allocated the array
267   TheItemType*         myData;      //!< Pointer to '0'th array item
268 };
269
270 #endif