0024831: Make iterators of NCollection classes STL-compatible
[occt.git] / src / NCollection / NCollection_BaseSequence.hxx
1 // Created on: 2002-04-10
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_BaseSequence_HeaderFile
17 #define NCollection_BaseSequence_HeaderFile
18
19 #include <Standard.hxx>
20 #include <NCollection_BaseAllocator.hxx>
21
22 // **************************************** Class SeqNode ********************
23
24 class NCollection_SeqNode 
25 {
26  public:
27   NCollection_SeqNode () : myNext (NULL), myPrevious (NULL) {}
28   NCollection_SeqNode * Next      () const { return myNext; }
29   NCollection_SeqNode * Previous  () const { return myPrevious; }
30   void SetNext     (NCollection_SeqNode * theNext) { myNext = theNext; }
31   void SetPrevious (NCollection_SeqNode * thePrev) { myPrevious = thePrev; }
32   
33  private:
34   NCollection_SeqNode* myNext;
35   NCollection_SeqNode* myPrevious;
36 };
37
38 typedef void (* NCollection_DelSeqNode) 
39      (NCollection_SeqNode*, Handle(NCollection_BaseAllocator)& theAl);
40
41 /**
42  * Purpose:     This  is  a base  class  for  the  Sequence.  It  deals with
43  *              an indexed bidirectional list of NCollection_SeqNode's.
44  */              
45 class NCollection_BaseSequence 
46 {
47  public:
48   class Iterator
49   {
50   public:
51     //! Empty constructor
52     Iterator (void) : myCurrent (NULL), myPrevious(NULL) {}
53
54     //! Constructor with initialisation
55     Iterator (const NCollection_BaseSequence& theSeq,
56               const Standard_Boolean isStart)
57     {
58       Init (theSeq, isStart);
59     }
60
61      //! Initialisation
62     void Init (const NCollection_BaseSequence& theSeq,
63                const Standard_Boolean isStart = Standard_True)
64     {
65       myCurrent  = (isStart ? theSeq.myFirstItem : NULL);
66       myPrevious = (isStart ? NULL : theSeq.myLastItem);
67     }
68
69     //! Assignment
70     Iterator& operator = (const Iterator& theOther)
71     {
72       myCurrent = theOther.myCurrent;
73       myPrevious = theOther.myPrevious;
74       return *this;
75     }
76     //! Switch to previous element; note that it will reset 
77     void Previous()
78     {
79       myCurrent = myPrevious;
80       if (myCurrent)
81         myPrevious = myCurrent->Previous();
82     }
83       
84   protected:
85     NCollection_SeqNode* myCurrent;  //!< Pointer to the current node
86     NCollection_SeqNode* myPrevious; //!< Pointer to the previous node
87     friend class NCollection_BaseSequence;
88   };
89
90  public:
91   // Methods PUBLIC
92   // 
93       Standard_Boolean   IsEmpty     () const {return (mySize == 0);}
94       Standard_Integer   Length      () const {return mySize;}
95
96  protected:
97   // Methods PROTECTED
98   // 
99   inline          NCollection_BaseSequence ();
100   Standard_EXPORT void   ClearSeq    (NCollection_DelSeqNode fDel,
101                                       Handle(NCollection_BaseAllocator)& theAl);
102   Standard_EXPORT void   PAppend     (NCollection_SeqNode *);
103   Standard_EXPORT void   PAppend     (NCollection_BaseSequence& S);
104   Standard_EXPORT void   PPrepend    (NCollection_SeqNode *);
105   Standard_EXPORT void   PPrepend    (NCollection_BaseSequence& S);
106   Standard_EXPORT void   PInsertAfter(Iterator& thePosition,
107                                       NCollection_SeqNode *);
108   Standard_EXPORT void   PInsertAfter(const Standard_Integer Index,
109                                       NCollection_SeqNode *);
110   Standard_EXPORT void   PInsertAfter(const Standard_Integer Index,
111                                       NCollection_BaseSequence& S);
112   Standard_EXPORT void   PSplit      (const Standard_Integer Index,
113                                       NCollection_BaseSequence& Sub);
114   Standard_EXPORT void   RemoveSeq   (Iterator& thePosition,
115                                       NCollection_DelSeqNode fDel,
116                                       Handle(NCollection_BaseAllocator)& theAl);
117   Standard_EXPORT void   RemoveSeq   (const Standard_Integer Index,
118                                       NCollection_DelSeqNode fDel,
119                                       Handle(NCollection_BaseAllocator)& theAl);
120   Standard_EXPORT void   RemoveSeq   (const Standard_Integer From,
121                                       const Standard_Integer To,
122                                       NCollection_DelSeqNode fDel,
123                                       Handle(NCollection_BaseAllocator)& theAl);
124   Standard_EXPORT void   PReverse    ();
125   Standard_EXPORT void   PExchange   (const Standard_Integer I,
126                                       const Standard_Integer J) ;
127   Standard_EXPORT NCollection_SeqNode *
128                          Find        (const Standard_Integer) const;
129
130  protected:
131   // Fields PROTECTED
132   //
133   NCollection_SeqNode* myFirstItem;
134   NCollection_SeqNode* myLastItem;
135   NCollection_SeqNode* myCurrentItem;
136   Standard_Integer myCurrentIndex;
137   Standard_Integer mySize;
138
139  private: 
140   // Methods PRIVATE
141   // 
142   Standard_EXPORT NCollection_BaseSequence
143                            (const NCollection_BaseSequence& Other);
144   inline void     Nullify ();
145   friend class Iterator;
146 };
147
148 inline NCollection_BaseSequence::NCollection_BaseSequence ()
149      : myFirstItem        (NULL),
150        myLastItem         (NULL),
151        myCurrentItem      (NULL),
152        myCurrentIndex     (0),
153        mySize             (0) {}
154
155 inline void NCollection_BaseSequence::Nullify ()
156 {
157   myFirstItem = myLastItem = myCurrentItem = NULL;
158   myCurrentIndex = mySize = 0;
159 }
160
161 #endif