0029151: GCC 7.1 warnings "this statement may fall through" [-Wimplicit-fallthrough=]
[occt.git] / src / NCollection / NCollection_BaseList.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 // Purpose:     This is a base  class  for the  List, Set, Queue  and Stack
17 //              collections. It offers operations on abstract lists (of the
18 //              objects of class NCollection_ListNode).
19 //              Apart from this class being  brand new (in TCollection said
20 //              collections were independent, only using the same class for
21 //              node representation),  here is an  important new  feature - 
22 //              the  list  length is  continuously updated,  so the  method 
23 //              Extent is quite quick.
24
25 #ifndef NCollection_BaseList_HeaderFile
26 #define NCollection_BaseList_HeaderFile
27
28 #include <Standard_NoSuchObject.hxx>
29 #include <NCollection_DefineAlloc.hxx>
30 #include <NCollection_ListNode.hxx>
31
32 typedef void (* NCollection_DelListNode) 
33      (NCollection_ListNode*, Handle(NCollection_BaseAllocator)& theAl);
34
35 // ********************************************************** BaseList class
36 class NCollection_BaseList
37 {
38 public:
39   //! Memory allocation
40   DEFINE_STANDARD_ALLOC
41   DEFINE_NCOLLECTION_ALLOC
42
43 public:
44   class Iterator
45   {
46   public:
47     // ******** Empty constructor
48     Iterator  (void) :
49       myCurrent (NULL),
50       myPrevious(NULL) {}
51     // ******** Constructor with initialisation
52     Iterator  (const NCollection_BaseList& theList) :
53       myCurrent (theList.myFirst),
54       myPrevious(NULL) {}
55     // ******** Initialisation
56     void Init (const NCollection_BaseList& theList)
57     {
58       myCurrent  = theList.myFirst;
59       myPrevious = NULL;
60     }
61     // ******** Initialisation
62     void Initialize (const NCollection_BaseList& theList)
63     {
64       Init(theList);
65     }
66     // ******** More
67     Standard_Boolean More (void) const
68     { return (myCurrent!=NULL); }
69     // ******** Assignment operator
70     Iterator& operator= (const Iterator& theIt)
71     {
72       if (&theIt != this)
73       {
74         myCurrent  = theIt.myCurrent;
75         myPrevious = theIt.myPrevious;
76       }
77       return * this;
78     }
79 //skt----------------------------------------------------
80     // ******** Comparison operator
81     Standard_Boolean operator== (const Iterator& theIt) const
82     {
83       return myCurrent == theIt.myCurrent;
84     }
85 //-------------------------------------------------------
86     //! Performs comparison of two iterators
87     Standard_Boolean IsEqual (const Iterator& theOther) const
88     {
89       return *this == theOther;
90     }
91   protected:
92     void Init (const NCollection_BaseList& theList,
93                NCollection_ListNode * const thePrev)
94     {
95       myCurrent  = thePrev ? thePrev -> Next() :
96                              (NCollection_ListNode *)theList.PLast();
97       myPrevious = thePrev;
98     }
99   public:
100     NCollection_ListNode * myCurrent; // Pointer to the current node
101     NCollection_ListNode * myPrevious;// Pointer to the previous one
102     friend class NCollection_BaseList;
103   }; // End of nested class Iterator
104
105  public:
106   // ---------- PUBLIC METHODS ------------
107   // ******** Extent
108   // Purpose: Returns the number of nodes in the list
109   Standard_Integer Extent (void) const
110   { return myLength; }
111
112   // ******** IsEmpty
113   // Purpose: Query if the list is empty
114   Standard_Boolean IsEmpty (void) const
115   { return (myFirst == NULL); }
116
117   // ******** Allocator
118   //! Returns attached allocator
119   const Handle(NCollection_BaseAllocator)& Allocator() const 
120   { return myAllocator; }
121
122   // ******** Destructor
123   // Purpose: defines virtual interface
124   virtual ~NCollection_BaseList (void)
125   {}
126
127  protected:
128   // --------- PROTECTED METHODS ----------
129
130   // ******** Constructor
131   // Purpose: Initializes an empty list
132   NCollection_BaseList (const Handle(NCollection_BaseAllocator)& theAllocator=0L) :
133     myFirst(NULL),
134     myLast(NULL),
135     myLength(0)
136   {
137     myAllocator = (theAllocator.IsNull() ? NCollection_BaseAllocator::CommonBaseAllocator() : theAllocator);
138   }
139
140   // ******** PClear
141   // Purpose: deletes all nodes
142   Standard_EXPORT void PClear (NCollection_DelListNode fDel);
143
144   // ******** PFirst
145   // Purpose: Returns pointer to the first node
146   const NCollection_ListNode* PFirst (void) const
147   { return myFirst; }
148
149   // ******** PLast
150   // Purpose: Returns pointer to the last node
151   const NCollection_ListNode* PLast (void) const
152   { return myLast; }
153
154   // ******** PAppend
155   // Purpose: Appends theNode at the end
156   Standard_EXPORT void PAppend (NCollection_ListNode* theNode);
157
158   // ******** PAppend
159   // Purpose: Appends theNode at the end, returns iterator to the previous
160   void                 PAppend (NCollection_ListNode* theNode,
161                                 Iterator&             theIt)
162   {
163     NCollection_ListNode * aPrev = myLast;
164     PAppend (theNode);
165     theIt.Init (* this, aPrev);
166   }
167
168   // ******** PAppend
169   // Purpose: Appends theOther list at the end (clearing it)
170   Standard_EXPORT void PAppend (NCollection_BaseList& theOther);
171
172   // ******** PPrepend
173   // Purpose: Prepends theNode at the beginning
174   Standard_EXPORT void PPrepend (NCollection_ListNode* theNode);
175
176   // ******** PPrepend
177   // Purpose: Prepends theOther list at the beginning (clearing it)
178   Standard_EXPORT void PPrepend (NCollection_BaseList& theOther);
179
180   // ******** PRemoveFirst
181   // Purpose: Removes first node
182   Standard_EXPORT void PRemoveFirst 
183     (NCollection_DelListNode fDel);
184
185   // ******** PRemove
186   // Purpose: Removes the node pointed by theIter[ator]
187   Standard_EXPORT void PRemove 
188     (Iterator& theIter,
189      NCollection_DelListNode fDel);
190
191   // ******** PInsertBefore
192   // Purpose: Inserts theNode before one pointed by theIter[ator]
193   Standard_EXPORT void PInsertBefore (NCollection_ListNode* theNode,
194                                       Iterator& theIter);
195
196   // ******** PInsertBefore
197   // Purpose: Inserts theOther list before the node pointed by theIter[ator]
198   Standard_EXPORT void PInsertBefore (NCollection_BaseList& theOther,
199                                       Iterator& theIter);
200
201   // ******** PInsertAfter
202   // Purpose: Inserts theNode after one pointed by theIter[ator]
203   Standard_EXPORT void PInsertAfter (NCollection_ListNode* theNode,
204                                      Iterator& theIter);
205
206   // ******** PInsertAfter
207   // Purpose: Inserts theOther list after the node pointed by theIter[ator]
208   Standard_EXPORT void PInsertAfter (NCollection_BaseList& theOther,
209                                      Iterator& theIter);
210
211   // ******** PReverse
212   // Purpose: Reverse the list
213   Standard_EXPORT void PReverse     ();
214
215  protected:
216   // ------------ PROTECTED FIELDS ------------
217   Handle(NCollection_BaseAllocator) myAllocator;
218   NCollection_ListNode * myFirst;  // Pointer to the head
219   NCollection_ListNode * myLast;   // Pointer to the tail
220   Standard_Integer       myLength; // Actual length
221
222   // ------------ FRIEND CLASSES ------------
223   friend class Iterator;
224 };
225
226 #endif