0027900: Coding rules - drop redundant Name parameter from V3d_Viewer constructor
[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   //! Remove the first occurrence of the object.
203   Standard_Boolean Remove (const TheItemType& theObject)
204   {
205     for (Iterator anIter (*this); anIter.More(); anIter.Next())
206     {
207       if (anIter.Value() == theObject)
208       {
209         Remove (anIter);
210         return Standard_True;
211       }
212     }
213     return Standard_False;
214   }
215
216   //! InsertBefore
217   TheItemType& InsertBefore (const TheItemType& theItem,
218                              Iterator& theIter) 
219   { 
220     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
221     PInsertBefore (pNew, theIter);
222     return pNew -> ChangeValue();
223   }
224
225   //! InsertBefore
226   void InsertBefore (NCollection_List& theOther,
227                      Iterator& theIter) 
228   {
229     if (this == &theOther) 
230       return;
231   
232     if (this->myAllocator == theOther.myAllocator)
233     {
234       // Then we take the list and glue it to our head - 
235       // deallocation will bring no problem
236       PInsertBefore (theOther, theIter);
237     }
238     else
239     {
240       // No - this list has different memory scope
241       prependList(theOther.myFirst, theIter);
242       theOther.Clear();
243     }
244   }
245
246   //! InsertAfter
247   TheItemType& InsertAfter (const TheItemType& theItem,
248                             Iterator& theIter) 
249   {
250     ListNode * pNew = new (this->myAllocator) ListNode(theItem);
251     PInsertAfter (pNew, theIter);
252     return pNew -> ChangeValue();
253   }
254
255   //! InsertAfter
256   void InsertAfter (NCollection_List& theOther,
257                     Iterator& theIter) 
258   {
259     if (!theIter.More())
260     {
261       Append(theOther);
262       return;
263     }
264     if (this->myAllocator == theOther.myAllocator)
265     {
266       // Then we take the list and glue it to our head - 
267       // deallocation will bring no problem
268       PInsertAfter (theOther, theIter);
269     }
270     else
271     {
272       // No - this list has different memory scope
273       Standard_NoSuchObject_Raise_if (!theIter.More(), "NCollection_List::InsertAfter");
274
275       Iterator anIter;
276       anIter.myPrevious = theIter.myCurrent;
277       anIter.myCurrent = theIter.myCurrent->Next();
278       prependList(theOther.PFirst(), anIter);
279       theOther.Clear();
280     }
281   }
282
283   //! Reverse the list
284   void Reverse ()
285   { PReverse(); }
286
287   //! Return true if object is stored in the list.
288   Standard_Boolean Contains (const TheItemType& theObject) const
289   {
290     for (Iterator anIter (*this); anIter.More(); anIter.Next())
291     {
292       if (anIter.Value() == theObject)
293       {
294         return Standard_True;
295       }
296     }
297     return Standard_False;
298   }
299
300   //! Destructor - clears the List
301   virtual ~NCollection_List (void)
302   { Clear(); }
303
304  private:
305   // ----------- PRIVATE METHODS -----------
306
307   //! append the list headed by the given ListNode
308   void appendList(const NCollection_ListNode * pCur) {
309     while (pCur) {
310       NCollection_ListNode * pNew =
311         new (this->myAllocator) ListNode(((const ListNode *)(pCur))->Value());
312       PAppend(pNew);
313       pCur = pCur->Next();
314     }
315   }
316
317   //! insert the list headed by the given ListNode before the given iterator
318   void prependList(const NCollection_ListNode * pCur, Iterator& theIter) {
319     while (pCur) {
320       NCollection_ListNode * pNew =
321         new (this->myAllocator) ListNode (((const ListNode *)(pCur))->Value());
322       PInsertBefore(pNew, theIter);
323       pCur = pCur->Next();
324     }
325   }
326 };
327
328 #endif