0024831: Make iterators of NCollection classes STL-compatible
[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_ListNode.hxx>
30
31 typedef void (* NCollection_DelListNode) 
32      (NCollection_ListNode*, Handle(NCollection_BaseAllocator)& theAl);
33
34 // ********************************************************** BaseList class
35 class NCollection_BaseList
36 {
37  public:
38   class Iterator
39   {
40   public:
41     // ******** Empty constructor
42     Iterator  (void) :
43       myCurrent (NULL),
44       myPrevious(NULL) {}
45     // ******** Constructor with initialisation
46     Iterator  (const NCollection_BaseList& theList) :
47       myCurrent (theList.myFirst),
48       myPrevious(NULL) {}
49     // ******** Initialisation
50     void Init (const NCollection_BaseList& theList)
51     {
52       myCurrent  = theList.myFirst;
53       myPrevious = NULL;
54     }
55     // ******** Initialisation
56     void Initialize (const NCollection_BaseList& theList)
57     {
58       Init(theList);
59     }
60     // ******** More
61     Standard_Boolean More (void) const
62     { return (myCurrent!=NULL); }
63     // ******** Assignment operator
64     Iterator& operator= (const Iterator& theIt)
65     {
66       if (&theIt != this)
67       {
68         myCurrent  = theIt.myCurrent;
69         myPrevious = theIt.myPrevious;
70       }
71       return * this;
72     }
73 //skt----------------------------------------------------
74     // ******** Comparison operator
75     Standard_Boolean operator== (const Iterator& theIt) const
76     {
77       return myCurrent == theIt.myCurrent;
78     }
79 //-------------------------------------------------------
80     //! Performs comparison of two iterators
81     virtual Standard_Boolean IsEqual (const Iterator& theOther) const
82     {
83       return *this == theOther;
84     }
85   protected:
86     void Init (const NCollection_BaseList& theList,
87                NCollection_ListNode * const thePrev)
88     {
89       myCurrent  = thePrev ? thePrev -> Next() :
90                              (NCollection_ListNode *)theList.PLast();
91       myPrevious = thePrev;
92     }
93   public:
94     NCollection_ListNode * myCurrent; // Pointer to the current node
95     NCollection_ListNode * myPrevious;// Pointer to the previous one
96     friend class NCollection_BaseList;
97   }; // End of nested class Iterator
98
99  public:
100   // ---------- PUBLIC METHODS ------------
101   // ******** Extent
102   // Purpose: Returns the number of nodes in the list
103   Standard_Integer Extent (void) const
104   { return myLength; }
105
106   // ******** IsEmpty
107   // Purpose: Query if the list is empty
108   Standard_Boolean IsEmpty (void) const
109   { return (myFirst == NULL); }
110
111  protected:
112   // --------- PROTECTED METHODS ----------
113
114   // ******** Constructor
115   // Purpose: Initializes an empty list
116   NCollection_BaseList(void) :
117     myFirst(NULL),
118     myLast(NULL),
119     myLength(0) {}
120
121   // ******** PClear
122   // Purpose: deletes all nodes
123   Standard_EXPORT void PClear (NCollection_DelListNode fDel,
124                                Handle(NCollection_BaseAllocator)& theAllocator);
125
126   // ******** PFirst
127   // Purpose: Returns pointer to the first node
128   const NCollection_ListNode* PFirst (void) const
129   { return myFirst; }
130
131   // ******** PLast
132   // Purpose: Returns pointer to the last node
133   const NCollection_ListNode* PLast (void) const
134   { return myLast; }
135
136   // ******** PAppend
137   // Purpose: Appends theNode at the end
138   Standard_EXPORT void PAppend (NCollection_ListNode* theNode);
139
140   // ******** PAppend
141   // Purpose: Appends theNode at the end, returns iterator to the previous
142   void                 PAppend (NCollection_ListNode* theNode,
143                                 Iterator&             theIt)
144   {
145     NCollection_ListNode * aPrev = myLast;
146     PAppend (theNode);
147     theIt.Init (* this, aPrev);
148   }
149
150   // ******** PAppend
151   // Purpose: Appends theOther list at the end (clearing it)
152   Standard_EXPORT void PAppend (NCollection_BaseList& theOther);
153
154   // ******** PPrepend
155   // Purpose: Prepends theNode at the beginning
156   Standard_EXPORT void PPrepend (NCollection_ListNode* theNode);
157
158   // ******** PPrepend
159   // Purpose: Prepends theOther list at the beginning (clearing it)
160   Standard_EXPORT void PPrepend (NCollection_BaseList& theOther);
161
162   // ******** PRemoveFirst
163   // Purpose: Removes first node
164   Standard_EXPORT void PRemoveFirst 
165     (NCollection_DelListNode fDel,
166      Handle(NCollection_BaseAllocator)& theAllocator);
167
168   // ******** PRemove
169   // Purpose: Removes the node pointed by theIter[ator]
170   Standard_EXPORT void PRemove 
171     (Iterator& theIter,
172      NCollection_DelListNode fDel,
173      Handle(NCollection_BaseAllocator)& theAllocator);
174
175   // ******** PInsertBefore
176   // Purpose: Inserts theNode before one pointed by theIter[ator]
177   Standard_EXPORT void PInsertBefore (NCollection_ListNode* theNode,
178                                       Iterator& theIter);
179
180   // ******** PInsertBefore
181   // Purpose: Inserts theOther list before the node pointed by theIter[ator]
182   Standard_EXPORT void PInsertBefore (NCollection_BaseList& theOther,
183                                       Iterator& theIter);
184
185   // ******** PInsertAfter
186   // Purpose: Inserts theNode after one pointed by theIter[ator]
187   Standard_EXPORT void PInsertAfter (NCollection_ListNode* theNode,
188                                      Iterator& theIter);
189
190   // ******** PInsertAfter
191   // Purpose: Inserts theOther list after the node pointed by theIter[ator]
192   Standard_EXPORT void PInsertAfter (NCollection_BaseList& theOther,
193                                      Iterator& theIter);
194
195   // ******** PReverse
196   // Purpose: Reverse the list
197   Standard_EXPORT void PReverse     ();
198
199  protected:
200   // ------------ PRIVATE FIELDS ------------
201   NCollection_ListNode * myFirst;  // Pointer to the head
202   NCollection_ListNode * myLast;   // Pointer to the tail
203   Standard_Integer       myLength; // Actual length
204
205   // ------------ FRIEND CLASSES ------------
206   friend class Iterator;
207 };
208
209 #endif