0022815: Missing delete operator for placement new
[occt.git] / src / Poly / Poly_CoherentTriPtr.hxx
1 // File:      Poly_CoherentTriPtr.hxx
2 // Created:   08.12.07 11:52
3 // Author:    Alexander GRIGORIEV
4 // Copyright: Open Cascade 2007
5
6
7 #ifndef Poly_CoherentTriPtr_HeaderFile
8 #define Poly_CoherentTriPtr_HeaderFile
9
10 #include <NCollection_BaseAllocator.hxx>
11 #include <NCollection_DefineAlloc.hxx>
12
13 class Poly_CoherentTriangle;
14
15 #ifdef WNT
16 #pragma warning (push)
17 #pragma warning(disable:4355) //'this' : used in base member initializer list
18 #endif
19
20 /**
21  * Implementation of both list node for Poly_CoherentTriangle type and
22  * round double-linked list of these nodes. 
23  */
24
25 class Poly_CoherentTriPtr
26 {
27  public:
28   /**
29    * Iterator class for this list of triangles. Because the list is round,
30    * an iteration can be started from any member and it finishes before taking
31    * this member again. The iteration sense is always forward (Next).
32    */  
33   class Iterator {
34   public:
35     //! Empty constructor
36     inline Iterator ()
37       : myFirst         (0L),
38         myCurrent       (0L)
39     {}
40     //! Constructor
41     inline Iterator (const Poly_CoherentTriPtr& thePtr)
42       : myFirst         (&thePtr),
43         myCurrent       (&thePtr)
44     {}
45     //! Query the triangle that started the current iteration.
46     inline const Poly_CoherentTriangle * First  () const
47     { return myFirst ? &myFirst->GetTriangle() : 0L; }
48     //! Query if there is available triangle pointer on this iteration
49     inline Standard_Boolean             More    () const
50     { return myCurrent != 0L; }
51     //! Go to the next iteration.
52     Standard_EXPORT void                Next    ();
53     //! Get the current iterated triangle
54     inline const Poly_CoherentTriangle& Value   () const
55     { return myCurrent->GetTriangle(); }
56     //! Get the current iterated triangle (mutable)
57     inline Poly_CoherentTriangle&       ChangeValue   () const
58     { return const_cast<Poly_CoherentTriangle&>(myCurrent->GetTriangle()); }
59     //! Get the current iterated pointer to triangle
60     inline const Poly_CoherentTriPtr&   PtrValue() const
61     { return * myCurrent; }
62   private:
63     const Poly_CoherentTriPtr * myFirst;
64     const Poly_CoherentTriPtr * myCurrent;
65   };
66
67   // ---------- PUBLIC METHODS ----------
68
69
70   /**
71    * Constructor.
72    */
73   inline Poly_CoherentTriPtr (const Poly_CoherentTriangle& theTri)
74     : mypTriangle (&theTri),
75       myNext      (this),
76       myPrevious  (this)
77   {}
78
79   /**
80    * Operator new for dynamic allocations
81    */
82   DEFINE_NCOLLECTION_ALLOC
83
84   /**
85    * Query the stored pointer to Triangle.
86    */
87   inline const Poly_CoherentTriangle&
88                         GetTriangle () const
89   { return * mypTriangle; }
90
91   /**
92    * Initialize this instance with a pointer to triangle.
93    */
94   inline void          SetTriangle (const Poly_CoherentTriangle * pTri)
95   { mypTriangle = pTri; }
96   
97   /**
98    * Query the next pointer in the list.
99    */
100   inline Poly_CoherentTriPtr&
101                        Next     () const
102   { return * myNext; }
103
104   /**
105    * Query the previous pointer in the list.
106    */
107   inline Poly_CoherentTriPtr&
108                        Previous () const
109   { return * myPrevious; }
110
111   /**
112    * Append a pointer to triangle into the list after the current instance.
113    * @param pTri
114    *   Triangle that is to be included in the list after this one.
115    * @param theA
116    *   Allocator where the new pointer instance is created.
117    */
118   Standard_EXPORT void Append   (const Poly_CoherentTriangle *           pTri,
119                                  const Handle_NCollection_BaseAllocator& theA);
120
121   /**
122    * Prepend a pointer to triangle into the list before the current instance.
123    * @param pTri
124    *   Triangle that is to be included in the list before this one.
125    * @param theA
126    *   Allocator where the new pointer instance is created.
127    */
128   Standard_EXPORT void Prepend  (const Poly_CoherentTriangle *           pTri,
129                                  const Handle_NCollection_BaseAllocator& theA);
130
131   /**
132    * Remove a pointer to triangle from its list.
133    * @param thePtr
134    *   This class instance that should be removed from its list.
135    * @param theA
136    *   Allocator where the current pointer instance was created.
137    */
138   Standard_EXPORT static void
139                        Remove   (Poly_CoherentTriPtr *                   thePtr,
140                                  const Handle_NCollection_BaseAllocator& theA);
141
142   /**
143    * Remove the list containing the given pointer to triangle.
144    */
145   Standard_EXPORT static void
146                        RemoveList (Poly_CoherentTriPtr *                 thePtr,
147                                    const Handle_NCollection_BaseAllocator&);
148
149  protected:
150   // ---------- PROTECTED METHODS ----------
151
152   /**
153    * Constructor.
154    */
155   inline Poly_CoherentTriPtr (const Poly_CoherentTriangle * pTri)
156     : mypTriangle (pTri),
157       myNext      (this),
158       myPrevious  (this)
159   {}
160
161  private:
162   // ---------- PRIVATE FIELDS ----------
163
164   const Poly_CoherentTriangle * mypTriangle;
165   Poly_CoherentTriPtr         * myNext;
166   Poly_CoherentTriPtr         * myPrevious;
167
168   friend class Iterator;
169 };
170
171 #ifdef WNT
172 #pragma warning (pop)
173 #endif
174
175 #endif