0025348: Method Assign of NCollection containers must not change own allocator of...
[occt.git] / src / NCollection / NCollection_List.hxx
1 // Created on: 2002-04-17
2 // Created by: Alexander Kartomin (akm)
3 // Copyright (c) 2002-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef NCollection_List_HeaderFile
17 #define NCollection_List_HeaderFile
18
19 #include <NCollection_TListIterator.hxx>
20 #include <NCollection_StlIterator.hxx>
21
22 #include <Standard_NoSuchObject.hxx>
23
24 /**
25  * Purpose:      Simple list to link  items together keeping the first 
26  *               and the last one.
27  *               Inherits BaseList, adding the data item to each node.
28  */               
29 template <class TheItemType>
30 class NCollection_List : public NCollection_BaseList
31 {
32 public:
33   //! STL-compliant typedef for value type
34   typedef TheItemType value_type;
35
36 public:
37   typedef NCollection_TListNode<TheItemType>     ListNode;
38   typedef NCollection_TListIterator<TheItemType> Iterator;
39
40   //! Shorthand for a regular iterator type.
41   typedef NCollection_StlIterator<std::forward_iterator_tag, Iterator, TheItemType, false> iterator;
42
43   //! Shorthand for a constant iterator type.
44   typedef NCollection_StlIterator<std::forward_iterator_tag, Iterator, TheItemType, true> const_iterator;
45
46   //! Returns an iterator pointing to the first element in the list.
47   iterator begin() const { return Iterator (*this); }
48
49   //! Returns an iterator referring to the past-the-end element in the list.
50   iterator end() const { return Iterator(); }
51
52   //! Returns a const iterator pointing to the first element in the list.
53   const_iterator cbegin() const { return Iterator (*this); }
54
55   //! Returns a const iterator referring to the past-the-end element in the list.
56   const_iterator cend() const { return Iterator(); }
57
58  public:
59   // ---------- PUBLIC METHODS ------------
60
61   //! Constructor
62   NCollection_List(const Handle(NCollection_BaseAllocator)& theAllocator=0L) :
63     NCollection_BaseList(theAllocator) {}
64
65   //! Copy constructor
66   NCollection_List (const NCollection_List& theOther) :
67     NCollection_BaseList(theOther.myAllocator)
68   {
69     Assign (theOther);
70   }
71
72   //! Size - Number of items
73   Standard_Integer Size (void) const
74   { return Extent(); }
75
76   //! Replace this list by the items of another list (theOther parameter).
77   //! This method does not change the internal allocator.
78   NCollection_List& Assign (const NCollection_List& theOther)
79   {
80     if (this != &theOther) {
81       Clear();
82       appendList(theOther.PFirst());
83     }
84     return *this;
85   }
86
87   //! Replacement operator
88   NCollection_List& operator= (const NCollection_List& theOther)
89   {
90     return Assign (theOther);
91   }
92
93   //! Clear this list
94   void Clear (const Handle(NCollection_BaseAllocator)& theAllocator=0L)
95   {
96     PClear (ListNode::delNode);
97     if (!theAllocator.IsNull())
98       this->myAllocator = theAllocator;
99   }
100
101   //! First item
102   const TheItemType& First (void) const
103   {
104     Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::First");
105     return ((const ListNode *) PFirst())->Value();
106   }
107
108   //! First item (non-const)
109   TheItemType& First (void)
110   {
111     Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::First");
112     return ((ListNode *) PFirst())->ChangeValue();
113   }
114
115   //! Last item
116   const TheItemType& Last (void) const
117   { 
118     Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::Last");
119     return ((const ListNode *) PLast())->Value();
120   }
121
122   //! Last item (non-const)
123   TheItemType& Last (void)
124   { 
125     Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::Last");
126     return ((ListNode *) PLast())->ChangeValue();
127   }
128
129   //! Append one item at the end
130   TheItemType& Append (const TheItemType& theItem)
131   { 
132     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
133     PAppend(pNew);
134     return ((ListNode *) PLast())->ChangeValue();
135   }
136
137   //! Append one item at the end and output iterator
138   //!   pointing at the appended item
139   void Append (const TheItemType& theItem, Iterator& theIter)
140   { 
141     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
142     PAppend(pNew, theIter);
143   }
144
145   //! Append another list at the end
146   void Append (NCollection_List& theOther)
147   { 
148     if (this == &theOther || theOther.Extent()<1)
149       return;
150     if (this->myAllocator == theOther.myAllocator)
151     {
152       // Then we take the list and glue it to our end - 
153       // deallocation will bring no problem
154       PAppend(theOther);
155     }
156     else
157     {
158       // No - this list has different memory scope
159       appendList(theOther.myFirst);
160       theOther.Clear();
161     }
162   }
163
164   //! Prepend one item at the beginning
165   TheItemType& Prepend (const TheItemType& theItem)
166   { 
167     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
168     PPrepend(pNew);
169     return ((ListNode *) PFirst())->ChangeValue();
170   }
171
172   //! Prepend another list at the beginning
173   void Prepend (NCollection_List& theOther)
174   { 
175     if (this == &theOther || theOther.Extent()<1) 
176       return;
177     if (this->myAllocator == theOther.myAllocator)
178     {
179       // Then we take the list and glue it to our head - 
180       // deallocation will bring no problem
181       PPrepend(theOther);
182     }
183     else
184     {
185       // No - this list has different memory scope
186       Iterator it(*this);
187       prependList(theOther.PFirst(), it);
188       theOther.Clear();
189     }
190   }
191
192   //! RemoveFirst item
193   void RemoveFirst (void) 
194   { PRemoveFirst (ListNode::delNode); }
195
196   //! Remove item
197   void Remove (Iterator& theIter) 
198   { 
199     PRemove (theIter, ListNode::delNode); 
200   }
201
202   //! InsertBefore
203   TheItemType& InsertBefore (const TheItemType& theItem,
204                              Iterator& theIter) 
205   { 
206     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
207     PInsertBefore (pNew, theIter);
208     return pNew -> ChangeValue();
209   }
210
211   //! InsertBefore
212   void InsertBefore (NCollection_List& theOther,
213                      Iterator& theIter) 
214   {
215     if (this == &theOther) 
216       return;
217   
218     if (this->myAllocator == theOther.myAllocator)
219     {
220       // Then we take the list and glue it to our head - 
221       // deallocation will bring no problem
222       PInsertBefore (theOther, theIter);
223     }
224     else
225     {
226       // No - this list has different memory scope
227       prependList(theOther.myFirst, theIter);
228       theOther.Clear();
229     }
230   }
231
232   //! InsertAfter
233   TheItemType& InsertAfter (const TheItemType& theItem,
234                             Iterator& theIter) 
235   {
236     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
237     PInsertAfter (pNew, theIter);
238     return pNew -> ChangeValue();
239   }
240
241   //! InsertAfter
242   void InsertAfter (NCollection_List& theOther,
243                     Iterator& theIter) 
244   {
245     if (!theIter.More())
246     {
247       Append(theOther);
248       return;
249     }
250     if (this->myAllocator == theOther.myAllocator)
251     {
252       // Then we take the list and glue it to our head - 
253       // deallocation will bring no problem
254       PInsertAfter (theOther, theIter);
255     }
256     else
257     {
258       // No - this list has different memory scope
259       Standard_NoSuchObject_Raise_if (!theIter.More(), "NCollection_List::InsertAfter");
260
261       Iterator anIter;
262       anIter.myPrevious = theIter.myCurrent;
263       anIter.myCurrent = theIter.myCurrent->Next();
264       prependList(theOther.PFirst(), anIter);
265       theOther.Clear();
266     }
267   }
268
269   //! Reverse the list
270   void Reverse ()
271   { PReverse(); }
272
273   //! Destructor - clears the List
274   ~NCollection_List (void)
275   { Clear(); }
276
277  private:
278   // ----------- PRIVATE METHODS -----------
279
280   //! append the list headed by the given ListNode
281   void appendList(const NCollection_ListNode * pCur) {
282     while (pCur) {
283       NCollection_ListNode * pNew =
284         new (this->myAllocator) ListNode(((const ListNode *)(pCur))->Value());
285       PAppend(pNew);
286       pCur = pCur->Next();
287     }
288   }
289
290   //! insert the list headed by the given ListNode before the given iterator
291   void prependList(const NCollection_ListNode * pCur, Iterator& theIter) {
292     while (pCur) {
293       NCollection_ListNode * pNew =
294         new (this->myAllocator) ListNode (((const ListNode *)(pCur))->Value());
295       PInsertBefore(pNew, theIter);
296       pCur = pCur->Next();
297     }
298   }
299 };
300
301 #endif