0027772: Foundation Classes - define Standard_Boolean using C++ type "bool" instead...
[occt.git] / src / HLRBRep / HLRBRep_EdgeData.lxx
1 // Created on: 1997-04-17
2 // Created by: Christophe MARION
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 //=======================================================================
18 //function : Selected
19 //purpose  : 
20 //=======================================================================
21
22 inline Standard_Boolean HLRBRep_EdgeData::Selected () const
23 { return (myFlags & EMaskSelected) != 0; }
24
25 //=======================================================================
26 //function : Selected
27 //purpose  : 
28 //=======================================================================
29
30 inline void HLRBRep_EdgeData::Selected (const Standard_Boolean B)
31 {
32   if (B) myFlags |=  EMaskSelected;
33   else   myFlags &= ~EMaskSelected;
34 }
35
36 //=======================================================================
37 //function : Rg1Line
38 //purpose  : 
39 //=======================================================================
40
41 inline Standard_Boolean HLRBRep_EdgeData::Rg1Line () const
42 { return (myFlags & EMaskRg1Line) != 0; }
43
44 //=======================================================================
45 //function : Rg1Line
46 //purpose  : 
47 //=======================================================================
48
49 inline void HLRBRep_EdgeData::Rg1Line (const Standard_Boolean B)
50 {
51   if (B) myFlags |=  EMaskRg1Line;
52   else   myFlags &= ~EMaskRg1Line;
53 }
54
55 //=======================================================================
56 //function : RgNLine
57 //purpose  : 
58 //=======================================================================
59
60 inline Standard_Boolean HLRBRep_EdgeData::RgNLine () const
61 { return (myFlags & EMaskRgNLine) != 0; }
62
63 //=======================================================================
64 //function : RgNLine
65 //purpose  : 
66 //=======================================================================
67
68 inline void HLRBRep_EdgeData::RgNLine (const Standard_Boolean B)
69 {
70   if (B) myFlags |=  EMaskRgNLine;
71   else   myFlags &= ~EMaskRgNLine;
72 }
73
74 //=======================================================================
75 //function : Vertical
76 //purpose  : 
77 //=======================================================================
78
79 inline Standard_Boolean HLRBRep_EdgeData::Vertical () const
80 { return (myFlags & EMaskVertical) != 0; }
81
82 //=======================================================================
83 //function : Vertical
84 //purpose  : 
85 //=======================================================================
86
87 inline void HLRBRep_EdgeData::Vertical(const Standard_Boolean B)
88 {
89   if (B) myFlags |=  EMaskVertical;
90   else   myFlags &= ~EMaskVertical;
91 }
92
93 //=======================================================================
94 //function : Simple
95 //purpose  : 
96 //=======================================================================
97
98 inline Standard_Boolean HLRBRep_EdgeData::Simple () const
99 { return (myFlags & EMaskSimple) != 0; }
100
101 //=======================================================================
102 //function : Simple
103 //purpose  : 
104 //=======================================================================
105
106 inline void HLRBRep_EdgeData::Simple (const Standard_Boolean B)
107 {
108   if (B) myFlags |=  EMaskSimple;
109   else   myFlags &= ~EMaskSimple;
110 }
111
112 //=======================================================================
113 //function : OutLVSta
114 //purpose  : 
115 //=======================================================================
116
117 inline Standard_Boolean HLRBRep_EdgeData::OutLVSta () const
118 { return (myFlags & EMaskOutLVSta) != 0; }
119
120 //=======================================================================
121 //function : OutLVSta
122 //purpose  : 
123 //=======================================================================
124
125 inline void HLRBRep_EdgeData::OutLVSta (const Standard_Boolean B)
126 {
127   if (B) myFlags |=  EMaskOutLVSta;
128   else   myFlags &= ~EMaskOutLVSta;
129 }
130
131 //=======================================================================
132 //function : OutLVEnd
133 //purpose  : 
134 //=======================================================================
135
136 inline Standard_Boolean HLRBRep_EdgeData::OutLVEnd () const
137 { return (myFlags & EMaskOutLVEnd) != 0; }
138
139 //=======================================================================
140 //function : OutLVEnd
141 //purpose  : 
142 //=======================================================================
143
144 inline void HLRBRep_EdgeData::OutLVEnd (const Standard_Boolean B)
145 {
146   if (B) myFlags |=  EMaskOutLVEnd;
147   else   myFlags &= ~EMaskOutLVEnd;
148 }
149
150 //=======================================================================
151 //function : CutAtSta
152 //purpose  : 
153 //=======================================================================
154
155 inline Standard_Boolean HLRBRep_EdgeData::CutAtSta () const
156 { return (myFlags & EMaskCutAtSta) != 0; }
157
158 //=======================================================================
159 //function : CutAtSta
160 //purpose  : 
161 //=======================================================================
162
163 inline void HLRBRep_EdgeData::CutAtSta (const Standard_Boolean B)
164 {
165   if (B) myFlags |=  EMaskCutAtSta;
166   else   myFlags &= ~EMaskCutAtSta;
167 }
168
169 //=======================================================================
170 //function : CutAtEnd
171 //purpose  : 
172 //=======================================================================
173
174 inline Standard_Boolean HLRBRep_EdgeData::CutAtEnd () const
175 { return (myFlags & EMaskCutAtEnd) != 0; }
176
177 //=======================================================================
178 //function : CutAtEnd
179 //purpose  : 
180 //=======================================================================
181
182 inline void HLRBRep_EdgeData::CutAtEnd (const Standard_Boolean B)
183 {
184   if (B) myFlags |=  EMaskCutAtEnd;
185   else   myFlags &= ~EMaskCutAtEnd;
186 }
187
188 //=======================================================================
189 //function : VerAtSta
190 //purpose  : 
191 //=======================================================================
192
193 inline Standard_Boolean HLRBRep_EdgeData::VerAtSta () const
194 { return (myFlags & EMaskVerAtSta) != 0; }
195
196 //=======================================================================
197 //function : VerAtSta
198 //purpose  : 
199 //=======================================================================
200
201 inline void HLRBRep_EdgeData::VerAtSta (const Standard_Boolean B)
202 {
203   if (B) myFlags |=  EMaskVerAtSta;
204   else   myFlags &= ~EMaskVerAtSta;
205 }
206
207 //=======================================================================
208 //function : VerAtEnd
209 //purpose  : 
210 //=======================================================================
211
212 inline Standard_Boolean HLRBRep_EdgeData::VerAtEnd () const
213 { return (myFlags & EMaskVerAtEnd) != 0; }
214
215 //=======================================================================
216 //function : VerAtEnd
217 //purpose  : 
218 //=======================================================================
219
220 inline void HLRBRep_EdgeData::VerAtEnd (const Standard_Boolean B)
221 {
222   if (B) myFlags |=  EMaskVerAtEnd;
223   else   myFlags &= ~EMaskVerAtEnd;
224 }
225
226 //=======================================================================
227 //function : AutoIntersectionDone
228 //purpose  : 
229 //=======================================================================
230
231 inline Standard_Boolean HLRBRep_EdgeData::AutoIntersectionDone () const
232 { return (myFlags & EMaskIntDone) != 0; }
233
234 //=======================================================================
235 //function : AutoIntersectionDone
236 //purpose  : 
237 //=======================================================================
238
239 inline void 
240 HLRBRep_EdgeData::AutoIntersectionDone (const Standard_Boolean B)
241 {
242   if (B) myFlags |=  EMaskIntDone;
243   else   myFlags &= ~EMaskIntDone;
244 }
245
246 //=======================================================================
247 //function : Used
248 //purpose  : 
249 //=======================================================================
250
251 inline Standard_Boolean HLRBRep_EdgeData::Used () const
252 { return (myFlags & EMaskUsed) != 0; }
253
254 //=======================================================================
255 //function : Used
256 //purpose  : 
257 //=======================================================================
258
259 inline void HLRBRep_EdgeData::Used (const Standard_Boolean B)
260 {
261   if (B) myFlags |=  EMaskUsed;
262   else   myFlags &= ~EMaskUsed;
263 }
264
265 //=======================================================================
266 //function : HideCount
267 //purpose  : 
268 //=======================================================================
269
270 inline Standard_Integer HLRBRep_EdgeData::HideCount () const
271 { return myHideCount; }
272
273 //=======================================================================
274 //function : HideCount
275 //purpose  : 
276 //=======================================================================
277
278 inline void HLRBRep_EdgeData::HideCount (const Standard_Integer I)
279 { myHideCount = I; }
280
281 //=======================================================================
282 //function : VSta
283 //purpose  : 
284 //=======================================================================
285
286 inline Standard_Integer HLRBRep_EdgeData::VSta() const
287 { return myVSta; }
288
289 //=======================================================================
290 //function : VSta
291 //purpose  : 
292 //=======================================================================
293
294 inline void HLRBRep_EdgeData::VSta (const Standard_Integer I)
295 { myVSta = I; }
296
297 //=======================================================================
298 //function : VEnd
299 //purpose  : 
300 //=======================================================================
301
302 inline Standard_Integer HLRBRep_EdgeData::VEnd () const
303 { return myVEnd; }
304
305 //=======================================================================
306 //function : VEnd
307 //purpose  : 
308 //=======================================================================
309
310 inline void HLRBRep_EdgeData::VEnd (const Standard_Integer I)
311 { myVEnd = I; }
312
313 //=======================================================================
314 //function : MinMax
315 //purpose  : 
316 //=======================================================================
317
318 inline Standard_Address HLRBRep_EdgeData::MinMax () const
319 { return (Standard_Address)&myMinMax; }
320
321 //=======================================================================
322 //function : Status
323 //purpose  : 
324 //=======================================================================
325
326 inline HLRAlgo_EdgeStatus & HLRBRep_EdgeData::Status ()
327 { return myStatus; }
328
329 //=======================================================================
330 //function : ChangeGeometry
331 //purpose  : 
332 //=======================================================================
333
334 inline HLRBRep_Curve & HLRBRep_EdgeData::ChangeGeometry ()
335 { return myGeometry; }
336
337 //=======================================================================
338 //function : Geometry
339 //purpose  : 
340 //=======================================================================
341
342 inline const HLRBRep_Curve & HLRBRep_EdgeData::Geometry () const
343 { return myGeometry; }
344
345 //=======================================================================
346 //function : Curve
347 //purpose  : 
348 //=======================================================================
349
350 inline Standard_Address HLRBRep_EdgeData::Curve ()
351 { return ((Standard_Address)&myGeometry); }
352
353 //=======================================================================
354 //function : Tolerance
355 //purpose  : 
356 //=======================================================================
357
358 inline Standard_ShortReal HLRBRep_EdgeData::Tolerance () const
359 { return myTolerance; }