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