1 ///////////////////////////////////////////////////////////////////////////////
2 // BSD 3-Clause License
3 //
4 // Copyright (c) 2020, The Regents of the University of California
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are met:
9 //
10 // * Redistributions of source code must retain the above copyright notice, this
11 // list of conditions and the following disclaimer.
12 //
13 // * Redistributions in binary form must reproduce the above copyright notice,
14 // this list of conditions and the following disclaimer in the documentation
15 // and/or other materials provided with the distribution.
16 //
17 // * Neither the name of the copyright holder nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
25 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 // POSSIBILITY OF SUCH DAMAGE.
32
33 // Generator Code Begin Cpp
34 #include "dbTechLayerCutEnclosureRule.h"
35
36 #include "db.h"
37 #include "dbDatabase.h"
38 #include "dbDiff.hpp"
39 #include "dbTable.h"
40 #include "dbTable.hpp"
41 #include "dbTechLayer.h"
42 #include "dbTechLayerCutClassRule.h"
43 // User Code Begin Includes
44 // User Code End Includes
45 namespace odb {
46
47 template class dbTable<_dbTechLayerCutEnclosureRule>;
48
operator ==(const _dbTechLayerCutEnclosureRule & rhs) const49 bool _dbTechLayerCutEnclosureRule::operator==(
50 const _dbTechLayerCutEnclosureRule& rhs) const
51 {
52 if (flags_.type_ != rhs.flags_.type_)
53 return false;
54
55 if (flags_.cut_class_valid_ != rhs.flags_.cut_class_valid_)
56 return false;
57
58 if (flags_.above_ != rhs.flags_.above_)
59 return false;
60
61 if (flags_.below_ != rhs.flags_.below_)
62 return false;
63
64 if (flags_.eol_min_length_valid_ != rhs.flags_.eol_min_length_valid_)
65 return false;
66
67 if (flags_.eol_only_ != rhs.flags_.eol_only_)
68 return false;
69
70 if (flags_.short_edge_only_ != rhs.flags_.short_edge_only_)
71 return false;
72
73 if (flags_.side_spacing_valid_ != rhs.flags_.side_spacing_valid_)
74 return false;
75
76 if (flags_.end_spacing_valid_ != rhs.flags_.end_spacing_valid_)
77 return false;
78
79 if (flags_.off_center_line_ != rhs.flags_.off_center_line_)
80 return false;
81
82 if (flags_.width_valid_ != rhs.flags_.width_valid_)
83 return false;
84
85 if (flags_.include_abutted_ != rhs.flags_.include_abutted_)
86 return false;
87
88 if (flags_.except_extra_cut_ != rhs.flags_.except_extra_cut_)
89 return false;
90
91 if (flags_.prl_ != rhs.flags_.prl_)
92 return false;
93
94 if (flags_.no_shared_edge_ != rhs.flags_.no_shared_edge_)
95 return false;
96
97 if (flags_.length_valid_ != rhs.flags_.length_valid_)
98 return false;
99
100 if (flags_.extra_cut_valid_ != rhs.flags_.extra_cut_valid_)
101 return false;
102
103 if (flags_.extra_only != rhs.flags_.extra_only)
104 return false;
105
106 if (flags_.redundant_cut_valid_ != rhs.flags_.redundant_cut_valid_)
107 return false;
108
109 if (flags_.parallel_valid_ != rhs.flags_.parallel_valid_)
110 return false;
111
112 if (flags_.second_parallel_valid != rhs.flags_.second_parallel_valid)
113 return false;
114
115 if (flags_.second_par_within_valid_ != rhs.flags_.second_par_within_valid_)
116 return false;
117
118 if (flags_.below_enclosure_valid_ != rhs.flags_.below_enclosure_valid_)
119 return false;
120
121 if (flags_.concave_corners_valid_ != rhs.flags_.concave_corners_valid_)
122 return false;
123
124 if (cut_class_ != rhs.cut_class_)
125 return false;
126
127 if (eol_width_ != rhs.eol_width_)
128 return false;
129
130 if (eol_min_length_ != rhs.eol_min_length_)
131 return false;
132
133 if (first_overhang_ != rhs.first_overhang_)
134 return false;
135
136 if (second_overhang_ != rhs.second_overhang_)
137 return false;
138
139 if (spacing_ != rhs.spacing_)
140 return false;
141
142 if (extension_ != rhs.extension_)
143 return false;
144
145 if (forward_extension_ != rhs.forward_extension_)
146 return false;
147
148 if (backward_extension_ != rhs.backward_extension_)
149 return false;
150
151 if (min_width_ != rhs.min_width_)
152 return false;
153
154 if (cut_within_ != rhs.cut_within_)
155 return false;
156
157 if (min_length_ != rhs.min_length_)
158 return false;
159
160 if (par_length_ != rhs.par_length_)
161 return false;
162
163 if (second_par_length_ != rhs.second_par_length_)
164 return false;
165
166 if (par_within_ != rhs.par_within_)
167 return false;
168
169 if (second_par_within_ != rhs.second_par_within_)
170 return false;
171
172 if (below_enclosure_ != rhs.below_enclosure_)
173 return false;
174
175 if (num_corners_ != rhs.num_corners_)
176 return false;
177
178 // User Code Begin ==
179 // User Code End ==
180 return true;
181 }
operator <(const _dbTechLayerCutEnclosureRule & rhs) const182 bool _dbTechLayerCutEnclosureRule::operator<(
183 const _dbTechLayerCutEnclosureRule& rhs) const
184 {
185 // User Code Begin <
186 // User Code End <
187 return true;
188 }
differences(dbDiff & diff,const char * field,const _dbTechLayerCutEnclosureRule & rhs) const189 void _dbTechLayerCutEnclosureRule::differences(
190 dbDiff& diff,
191 const char* field,
192 const _dbTechLayerCutEnclosureRule& rhs) const
193 {
194 DIFF_BEGIN
195
196 DIFF_FIELD(flags_.type_);
197 DIFF_FIELD(flags_.cut_class_valid_);
198 DIFF_FIELD(flags_.above_);
199 DIFF_FIELD(flags_.below_);
200 DIFF_FIELD(flags_.eol_min_length_valid_);
201 DIFF_FIELD(flags_.eol_only_);
202 DIFF_FIELD(flags_.short_edge_only_);
203 DIFF_FIELD(flags_.side_spacing_valid_);
204 DIFF_FIELD(flags_.end_spacing_valid_);
205 DIFF_FIELD(flags_.off_center_line_);
206 DIFF_FIELD(flags_.width_valid_);
207 DIFF_FIELD(flags_.include_abutted_);
208 DIFF_FIELD(flags_.except_extra_cut_);
209 DIFF_FIELD(flags_.prl_);
210 DIFF_FIELD(flags_.no_shared_edge_);
211 DIFF_FIELD(flags_.length_valid_);
212 DIFF_FIELD(flags_.extra_cut_valid_);
213 DIFF_FIELD(flags_.extra_only);
214 DIFF_FIELD(flags_.redundant_cut_valid_);
215 DIFF_FIELD(flags_.parallel_valid_);
216 DIFF_FIELD(flags_.second_parallel_valid);
217 DIFF_FIELD(flags_.second_par_within_valid_);
218 DIFF_FIELD(flags_.below_enclosure_valid_);
219 DIFF_FIELD(flags_.concave_corners_valid_);
220 DIFF_FIELD(cut_class_);
221 DIFF_FIELD(eol_width_);
222 DIFF_FIELD(eol_min_length_);
223 DIFF_FIELD(first_overhang_);
224 DIFF_FIELD(second_overhang_);
225 DIFF_FIELD(spacing_);
226 DIFF_FIELD(extension_);
227 DIFF_FIELD(forward_extension_);
228 DIFF_FIELD(backward_extension_);
229 DIFF_FIELD(min_width_);
230 DIFF_FIELD(cut_within_);
231 DIFF_FIELD(min_length_);
232 DIFF_FIELD(par_length_);
233 DIFF_FIELD(second_par_length_);
234 DIFF_FIELD(par_within_);
235 DIFF_FIELD(second_par_within_);
236 DIFF_FIELD(below_enclosure_);
237 DIFF_FIELD(num_corners_);
238 // User Code Begin Differences
239 // User Code End Differences
240 DIFF_END
241 }
out(dbDiff & diff,char side,const char * field) const242 void _dbTechLayerCutEnclosureRule::out(dbDiff& diff,
243 char side,
244 const char* field) const
245 {
246 DIFF_OUT_BEGIN
247 DIFF_OUT_FIELD(flags_.type_);
248 DIFF_OUT_FIELD(flags_.cut_class_valid_);
249 DIFF_OUT_FIELD(flags_.above_);
250 DIFF_OUT_FIELD(flags_.below_);
251 DIFF_OUT_FIELD(flags_.eol_min_length_valid_);
252 DIFF_OUT_FIELD(flags_.eol_only_);
253 DIFF_OUT_FIELD(flags_.short_edge_only_);
254 DIFF_OUT_FIELD(flags_.side_spacing_valid_);
255 DIFF_OUT_FIELD(flags_.end_spacing_valid_);
256 DIFF_OUT_FIELD(flags_.off_center_line_);
257 DIFF_OUT_FIELD(flags_.width_valid_);
258 DIFF_OUT_FIELD(flags_.include_abutted_);
259 DIFF_OUT_FIELD(flags_.except_extra_cut_);
260 DIFF_OUT_FIELD(flags_.prl_);
261 DIFF_OUT_FIELD(flags_.no_shared_edge_);
262 DIFF_OUT_FIELD(flags_.length_valid_);
263 DIFF_OUT_FIELD(flags_.extra_cut_valid_);
264 DIFF_OUT_FIELD(flags_.extra_only);
265 DIFF_OUT_FIELD(flags_.redundant_cut_valid_);
266 DIFF_OUT_FIELD(flags_.parallel_valid_);
267 DIFF_OUT_FIELD(flags_.second_parallel_valid);
268 DIFF_OUT_FIELD(flags_.second_par_within_valid_);
269 DIFF_OUT_FIELD(flags_.below_enclosure_valid_);
270 DIFF_OUT_FIELD(flags_.concave_corners_valid_);
271 DIFF_OUT_FIELD(cut_class_);
272 DIFF_OUT_FIELD(eol_width_);
273 DIFF_OUT_FIELD(eol_min_length_);
274 DIFF_OUT_FIELD(first_overhang_);
275 DIFF_OUT_FIELD(second_overhang_);
276 DIFF_OUT_FIELD(spacing_);
277 DIFF_OUT_FIELD(extension_);
278 DIFF_OUT_FIELD(forward_extension_);
279 DIFF_OUT_FIELD(backward_extension_);
280 DIFF_OUT_FIELD(min_width_);
281 DIFF_OUT_FIELD(cut_within_);
282 DIFF_OUT_FIELD(min_length_);
283 DIFF_OUT_FIELD(par_length_);
284 DIFF_OUT_FIELD(second_par_length_);
285 DIFF_OUT_FIELD(par_within_);
286 DIFF_OUT_FIELD(second_par_within_);
287 DIFF_OUT_FIELD(below_enclosure_);
288 DIFF_OUT_FIELD(num_corners_);
289
290 // User Code Begin Out
291 // User Code End Out
292 DIFF_END
293 }
_dbTechLayerCutEnclosureRule(_dbDatabase * db)294 _dbTechLayerCutEnclosureRule::_dbTechLayerCutEnclosureRule(_dbDatabase* db)
295 {
296 uint32_t* flags__bit_field = (uint32_t*) &flags_;
297 *flags__bit_field = 0;
298 eol_width_ = 0;
299 eol_min_length_ = 0;
300 first_overhang_ = 0;
301 second_overhang_ = 0;
302 spacing_ = 0;
303 extension_ = 0;
304 forward_extension_ = 0;
305 backward_extension_ = 0;
306 min_width_ = 0;
307 cut_within_ = 0;
308 min_length_ = 0;
309 par_length_ = 0;
310 second_par_length_ = 0;
311 par_within_ = 0;
312 second_par_within_ = 0;
313 below_enclosure_ = 0;
314 num_corners_ = 0;
315 // User Code Begin Constructor
316 // User Code End Constructor
317 }
_dbTechLayerCutEnclosureRule(_dbDatabase * db,const _dbTechLayerCutEnclosureRule & r)318 _dbTechLayerCutEnclosureRule::_dbTechLayerCutEnclosureRule(
319 _dbDatabase* db,
320 const _dbTechLayerCutEnclosureRule& r)
321 {
322 flags_.type_ = r.flags_.type_;
323 flags_.cut_class_valid_ = r.flags_.cut_class_valid_;
324 flags_.above_ = r.flags_.above_;
325 flags_.below_ = r.flags_.below_;
326 flags_.eol_min_length_valid_ = r.flags_.eol_min_length_valid_;
327 flags_.eol_only_ = r.flags_.eol_only_;
328 flags_.short_edge_only_ = r.flags_.short_edge_only_;
329 flags_.side_spacing_valid_ = r.flags_.side_spacing_valid_;
330 flags_.end_spacing_valid_ = r.flags_.end_spacing_valid_;
331 flags_.off_center_line_ = r.flags_.off_center_line_;
332 flags_.width_valid_ = r.flags_.width_valid_;
333 flags_.include_abutted_ = r.flags_.include_abutted_;
334 flags_.except_extra_cut_ = r.flags_.except_extra_cut_;
335 flags_.prl_ = r.flags_.prl_;
336 flags_.no_shared_edge_ = r.flags_.no_shared_edge_;
337 flags_.length_valid_ = r.flags_.length_valid_;
338 flags_.extra_cut_valid_ = r.flags_.extra_cut_valid_;
339 flags_.extra_only = r.flags_.extra_only;
340 flags_.redundant_cut_valid_ = r.flags_.redundant_cut_valid_;
341 flags_.parallel_valid_ = r.flags_.parallel_valid_;
342 flags_.second_parallel_valid = r.flags_.second_parallel_valid;
343 flags_.second_par_within_valid_ = r.flags_.second_par_within_valid_;
344 flags_.below_enclosure_valid_ = r.flags_.below_enclosure_valid_;
345 flags_.concave_corners_valid_ = r.flags_.concave_corners_valid_;
346 flags_.spare_bits_ = r.flags_.spare_bits_;
347 cut_class_ = r.cut_class_;
348 eol_width_ = r.eol_width_;
349 eol_min_length_ = r.eol_min_length_;
350 first_overhang_ = r.first_overhang_;
351 second_overhang_ = r.second_overhang_;
352 spacing_ = r.spacing_;
353 extension_ = r.extension_;
354 forward_extension_ = r.forward_extension_;
355 backward_extension_ = r.backward_extension_;
356 min_width_ = r.min_width_;
357 cut_within_ = r.cut_within_;
358 min_length_ = r.min_length_;
359 par_length_ = r.par_length_;
360 second_par_length_ = r.second_par_length_;
361 par_within_ = r.par_within_;
362 second_par_within_ = r.second_par_within_;
363 below_enclosure_ = r.below_enclosure_;
364 num_corners_ = r.num_corners_;
365 // User Code Begin CopyConstructor
366 // User Code End CopyConstructor
367 }
368
operator >>(dbIStream & stream,_dbTechLayerCutEnclosureRule & obj)369 dbIStream& operator>>(dbIStream& stream, _dbTechLayerCutEnclosureRule& obj)
370 {
371 uint32_t* flags__bit_field = (uint32_t*) &obj.flags_;
372 stream >> *flags__bit_field;
373 stream >> obj.cut_class_;
374 stream >> obj.eol_width_;
375 stream >> obj.eol_min_length_;
376 stream >> obj.first_overhang_;
377 stream >> obj.second_overhang_;
378 stream >> obj.spacing_;
379 stream >> obj.extension_;
380 stream >> obj.forward_extension_;
381 stream >> obj.backward_extension_;
382 stream >> obj.min_width_;
383 stream >> obj.cut_within_;
384 stream >> obj.min_length_;
385 stream >> obj.par_length_;
386 stream >> obj.second_par_length_;
387 stream >> obj.par_within_;
388 stream >> obj.second_par_within_;
389 stream >> obj.below_enclosure_;
390 stream >> obj.num_corners_;
391 // User Code Begin >>
392 // User Code End >>
393 return stream;
394 }
operator <<(dbOStream & stream,const _dbTechLayerCutEnclosureRule & obj)395 dbOStream& operator<<(dbOStream& stream,
396 const _dbTechLayerCutEnclosureRule& obj)
397 {
398 uint32_t* flags__bit_field = (uint32_t*) &obj.flags_;
399 stream << *flags__bit_field;
400 stream << obj.cut_class_;
401 stream << obj.eol_width_;
402 stream << obj.eol_min_length_;
403 stream << obj.first_overhang_;
404 stream << obj.second_overhang_;
405 stream << obj.spacing_;
406 stream << obj.extension_;
407 stream << obj.forward_extension_;
408 stream << obj.backward_extension_;
409 stream << obj.min_width_;
410 stream << obj.cut_within_;
411 stream << obj.min_length_;
412 stream << obj.par_length_;
413 stream << obj.second_par_length_;
414 stream << obj.par_within_;
415 stream << obj.second_par_within_;
416 stream << obj.below_enclosure_;
417 stream << obj.num_corners_;
418 // User Code Begin <<
419 // User Code End <<
420 return stream;
421 }
422
~_dbTechLayerCutEnclosureRule()423 _dbTechLayerCutEnclosureRule::~_dbTechLayerCutEnclosureRule()
424 {
425 // User Code Begin Destructor
426 // User Code End Destructor
427 }
428
429 // User Code Begin PrivateMethods
430 // User Code End PrivateMethods
431
432 ////////////////////////////////////////////////////////////////////
433 //
434 // dbTechLayerCutEnclosureRule - Methods
435 //
436 ////////////////////////////////////////////////////////////////////
437
setCutClass(dbTechLayerCutClassRule * cut_class)438 void dbTechLayerCutEnclosureRule::setCutClass(
439 dbTechLayerCutClassRule* cut_class)
440 {
441 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
442
443 obj->cut_class_ = cut_class->getImpl()->getOID();
444 }
445
getCutClass() const446 dbTechLayerCutClassRule* dbTechLayerCutEnclosureRule::getCutClass() const
447 {
448 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
449 if (obj->cut_class_ == 0)
450 return NULL;
451 _dbTechLayer* par = (_dbTechLayer*) obj->getOwner();
452 return (dbTechLayerCutClassRule*) par->cut_class_rules_tbl_->getPtr(
453 obj->cut_class_);
454 }
455
setEolWidth(int eol_width)456 void dbTechLayerCutEnclosureRule::setEolWidth(int eol_width)
457 {
458 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
459
460 obj->eol_width_ = eol_width;
461 }
462
getEolWidth() const463 int dbTechLayerCutEnclosureRule::getEolWidth() const
464 {
465 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
466 return obj->eol_width_;
467 }
468
setEolMinLength(int eol_min_length)469 void dbTechLayerCutEnclosureRule::setEolMinLength(int eol_min_length)
470 {
471 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
472
473 obj->eol_min_length_ = eol_min_length;
474 }
475
getEolMinLength() const476 int dbTechLayerCutEnclosureRule::getEolMinLength() const
477 {
478 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
479 return obj->eol_min_length_;
480 }
481
setFirstOverhang(int first_overhang)482 void dbTechLayerCutEnclosureRule::setFirstOverhang(int first_overhang)
483 {
484 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
485
486 obj->first_overhang_ = first_overhang;
487 }
488
getFirstOverhang() const489 int dbTechLayerCutEnclosureRule::getFirstOverhang() const
490 {
491 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
492 return obj->first_overhang_;
493 }
494
setSecondOverhang(int second_overhang)495 void dbTechLayerCutEnclosureRule::setSecondOverhang(int second_overhang)
496 {
497 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
498
499 obj->second_overhang_ = second_overhang;
500 }
501
getSecondOverhang() const502 int dbTechLayerCutEnclosureRule::getSecondOverhang() const
503 {
504 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
505 return obj->second_overhang_;
506 }
507
setSpacing(int spacing)508 void dbTechLayerCutEnclosureRule::setSpacing(int spacing)
509 {
510 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
511
512 obj->spacing_ = spacing;
513 }
514
getSpacing() const515 int dbTechLayerCutEnclosureRule::getSpacing() const
516 {
517 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
518 return obj->spacing_;
519 }
520
setExtension(int extension)521 void dbTechLayerCutEnclosureRule::setExtension(int extension)
522 {
523 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
524
525 obj->extension_ = extension;
526 }
527
getExtension() const528 int dbTechLayerCutEnclosureRule::getExtension() const
529 {
530 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
531 return obj->extension_;
532 }
533
setForwardExtension(int forward_extension)534 void dbTechLayerCutEnclosureRule::setForwardExtension(int forward_extension)
535 {
536 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
537
538 obj->forward_extension_ = forward_extension;
539 }
540
getForwardExtension() const541 int dbTechLayerCutEnclosureRule::getForwardExtension() const
542 {
543 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
544 return obj->forward_extension_;
545 }
546
setBackwardExtension(int backward_extension)547 void dbTechLayerCutEnclosureRule::setBackwardExtension(int backward_extension)
548 {
549 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
550
551 obj->backward_extension_ = backward_extension;
552 }
553
getBackwardExtension() const554 int dbTechLayerCutEnclosureRule::getBackwardExtension() const
555 {
556 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
557 return obj->backward_extension_;
558 }
559
setMinWidth(int min_width)560 void dbTechLayerCutEnclosureRule::setMinWidth(int min_width)
561 {
562 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
563
564 obj->min_width_ = min_width;
565 }
566
getMinWidth() const567 int dbTechLayerCutEnclosureRule::getMinWidth() const
568 {
569 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
570 return obj->min_width_;
571 }
572
setCutWithin(int cut_within)573 void dbTechLayerCutEnclosureRule::setCutWithin(int cut_within)
574 {
575 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
576
577 obj->cut_within_ = cut_within;
578 }
579
getCutWithin() const580 int dbTechLayerCutEnclosureRule::getCutWithin() const
581 {
582 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
583 return obj->cut_within_;
584 }
585
setMinLength(int min_length)586 void dbTechLayerCutEnclosureRule::setMinLength(int min_length)
587 {
588 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
589
590 obj->min_length_ = min_length;
591 }
592
getMinLength() const593 int dbTechLayerCutEnclosureRule::getMinLength() const
594 {
595 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
596 return obj->min_length_;
597 }
598
setParLength(int par_length)599 void dbTechLayerCutEnclosureRule::setParLength(int par_length)
600 {
601 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
602
603 obj->par_length_ = par_length;
604 }
605
getParLength() const606 int dbTechLayerCutEnclosureRule::getParLength() const
607 {
608 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
609 return obj->par_length_;
610 }
611
setSecondParLength(int second_par_length)612 void dbTechLayerCutEnclosureRule::setSecondParLength(int second_par_length)
613 {
614 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
615
616 obj->second_par_length_ = second_par_length;
617 }
618
getSecondParLength() const619 int dbTechLayerCutEnclosureRule::getSecondParLength() const
620 {
621 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
622 return obj->second_par_length_;
623 }
624
setParWithin(int par_within)625 void dbTechLayerCutEnclosureRule::setParWithin(int par_within)
626 {
627 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
628
629 obj->par_within_ = par_within;
630 }
631
getParWithin() const632 int dbTechLayerCutEnclosureRule::getParWithin() const
633 {
634 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
635 return obj->par_within_;
636 }
637
setSecondParWithin(int second_par_within)638 void dbTechLayerCutEnclosureRule::setSecondParWithin(int second_par_within)
639 {
640 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
641
642 obj->second_par_within_ = second_par_within;
643 }
644
getSecondParWithin() const645 int dbTechLayerCutEnclosureRule::getSecondParWithin() const
646 {
647 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
648 return obj->second_par_within_;
649 }
650
setBelowEnclosure(int below_enclosure)651 void dbTechLayerCutEnclosureRule::setBelowEnclosure(int below_enclosure)
652 {
653 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
654
655 obj->below_enclosure_ = below_enclosure;
656 }
657
getBelowEnclosure() const658 int dbTechLayerCutEnclosureRule::getBelowEnclosure() const
659 {
660 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
661 return obj->below_enclosure_;
662 }
663
setNumCorners(uint num_corners)664 void dbTechLayerCutEnclosureRule::setNumCorners(uint num_corners)
665 {
666 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
667
668 obj->num_corners_ = num_corners;
669 }
670
getNumCorners() const671 uint dbTechLayerCutEnclosureRule::getNumCorners() const
672 {
673 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
674 return obj->num_corners_;
675 }
676
setCutClassValid(bool cut_class_valid)677 void dbTechLayerCutEnclosureRule::setCutClassValid(bool cut_class_valid)
678 {
679 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
680
681 obj->flags_.cut_class_valid_ = cut_class_valid;
682 }
683
isCutClassValid() const684 bool dbTechLayerCutEnclosureRule::isCutClassValid() const
685 {
686 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
687
688 return obj->flags_.cut_class_valid_;
689 }
690
setAbove(bool above)691 void dbTechLayerCutEnclosureRule::setAbove(bool above)
692 {
693 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
694
695 obj->flags_.above_ = above;
696 }
697
isAbove() const698 bool dbTechLayerCutEnclosureRule::isAbove() const
699 {
700 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
701
702 return obj->flags_.above_;
703 }
704
setBelow(bool below)705 void dbTechLayerCutEnclosureRule::setBelow(bool below)
706 {
707 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
708
709 obj->flags_.below_ = below;
710 }
711
isBelow() const712 bool dbTechLayerCutEnclosureRule::isBelow() const
713 {
714 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
715
716 return obj->flags_.below_;
717 }
718
setEolMinLengthValid(bool eol_min_length_valid)719 void dbTechLayerCutEnclosureRule::setEolMinLengthValid(
720 bool eol_min_length_valid)
721 {
722 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
723
724 obj->flags_.eol_min_length_valid_ = eol_min_length_valid;
725 }
726
isEolMinLengthValid() const727 bool dbTechLayerCutEnclosureRule::isEolMinLengthValid() const
728 {
729 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
730
731 return obj->flags_.eol_min_length_valid_;
732 }
733
setEolOnly(bool eol_only)734 void dbTechLayerCutEnclosureRule::setEolOnly(bool eol_only)
735 {
736 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
737
738 obj->flags_.eol_only_ = eol_only;
739 }
740
isEolOnly() const741 bool dbTechLayerCutEnclosureRule::isEolOnly() const
742 {
743 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
744
745 return obj->flags_.eol_only_;
746 }
747
setShortEdgeOnly(bool short_edge_only)748 void dbTechLayerCutEnclosureRule::setShortEdgeOnly(bool short_edge_only)
749 {
750 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
751
752 obj->flags_.short_edge_only_ = short_edge_only;
753 }
754
isShortEdgeOnly() const755 bool dbTechLayerCutEnclosureRule::isShortEdgeOnly() const
756 {
757 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
758
759 return obj->flags_.short_edge_only_;
760 }
761
setSideSpacingValid(bool side_spacing_valid)762 void dbTechLayerCutEnclosureRule::setSideSpacingValid(bool side_spacing_valid)
763 {
764 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
765
766 obj->flags_.side_spacing_valid_ = side_spacing_valid;
767 }
768
isSideSpacingValid() const769 bool dbTechLayerCutEnclosureRule::isSideSpacingValid() const
770 {
771 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
772
773 return obj->flags_.side_spacing_valid_;
774 }
775
setEndSpacingValid(bool end_spacing_valid)776 void dbTechLayerCutEnclosureRule::setEndSpacingValid(bool end_spacing_valid)
777 {
778 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
779
780 obj->flags_.end_spacing_valid_ = end_spacing_valid;
781 }
782
isEndSpacingValid() const783 bool dbTechLayerCutEnclosureRule::isEndSpacingValid() const
784 {
785 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
786
787 return obj->flags_.end_spacing_valid_;
788 }
789
setOffCenterLine(bool off_center_line)790 void dbTechLayerCutEnclosureRule::setOffCenterLine(bool off_center_line)
791 {
792 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
793
794 obj->flags_.off_center_line_ = off_center_line;
795 }
796
isOffCenterLine() const797 bool dbTechLayerCutEnclosureRule::isOffCenterLine() const
798 {
799 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
800
801 return obj->flags_.off_center_line_;
802 }
803
setWidthValid(bool width_valid)804 void dbTechLayerCutEnclosureRule::setWidthValid(bool width_valid)
805 {
806 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
807
808 obj->flags_.width_valid_ = width_valid;
809 }
810
isWidthValid() const811 bool dbTechLayerCutEnclosureRule::isWidthValid() const
812 {
813 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
814
815 return obj->flags_.width_valid_;
816 }
817
setIncludeAbutted(bool include_abutted)818 void dbTechLayerCutEnclosureRule::setIncludeAbutted(bool include_abutted)
819 {
820 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
821
822 obj->flags_.include_abutted_ = include_abutted;
823 }
824
isIncludeAbutted() const825 bool dbTechLayerCutEnclosureRule::isIncludeAbutted() const
826 {
827 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
828
829 return obj->flags_.include_abutted_;
830 }
831
setExceptExtraCut(bool except_extra_cut)832 void dbTechLayerCutEnclosureRule::setExceptExtraCut(bool except_extra_cut)
833 {
834 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
835
836 obj->flags_.except_extra_cut_ = except_extra_cut;
837 }
838
isExceptExtraCut() const839 bool dbTechLayerCutEnclosureRule::isExceptExtraCut() const
840 {
841 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
842
843 return obj->flags_.except_extra_cut_;
844 }
845
setPrl(bool prl)846 void dbTechLayerCutEnclosureRule::setPrl(bool prl)
847 {
848 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
849
850 obj->flags_.prl_ = prl;
851 }
852
isPrl() const853 bool dbTechLayerCutEnclosureRule::isPrl() const
854 {
855 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
856
857 return obj->flags_.prl_;
858 }
859
setNoSharedEdge(bool no_shared_edge)860 void dbTechLayerCutEnclosureRule::setNoSharedEdge(bool no_shared_edge)
861 {
862 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
863
864 obj->flags_.no_shared_edge_ = no_shared_edge;
865 }
866
isNoSharedEdge() const867 bool dbTechLayerCutEnclosureRule::isNoSharedEdge() const
868 {
869 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
870
871 return obj->flags_.no_shared_edge_;
872 }
873
setLengthValid(bool length_valid)874 void dbTechLayerCutEnclosureRule::setLengthValid(bool length_valid)
875 {
876 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
877
878 obj->flags_.length_valid_ = length_valid;
879 }
880
isLengthValid() const881 bool dbTechLayerCutEnclosureRule::isLengthValid() const
882 {
883 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
884
885 return obj->flags_.length_valid_;
886 }
887
setExtraCutValid(bool extra_cut_valid)888 void dbTechLayerCutEnclosureRule::setExtraCutValid(bool extra_cut_valid)
889 {
890 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
891
892 obj->flags_.extra_cut_valid_ = extra_cut_valid;
893 }
894
isExtraCutValid() const895 bool dbTechLayerCutEnclosureRule::isExtraCutValid() const
896 {
897 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
898
899 return obj->flags_.extra_cut_valid_;
900 }
901
setExtraOnly(bool extra_only)902 void dbTechLayerCutEnclosureRule::setExtraOnly(bool extra_only)
903 {
904 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
905
906 obj->flags_.extra_only = extra_only;
907 }
908
isExtraOnly() const909 bool dbTechLayerCutEnclosureRule::isExtraOnly() const
910 {
911 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
912
913 return obj->flags_.extra_only;
914 }
915
setRedundantCutValid(bool redundant_cut_valid)916 void dbTechLayerCutEnclosureRule::setRedundantCutValid(bool redundant_cut_valid)
917 {
918 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
919
920 obj->flags_.redundant_cut_valid_ = redundant_cut_valid;
921 }
922
isRedundantCutValid() const923 bool dbTechLayerCutEnclosureRule::isRedundantCutValid() const
924 {
925 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
926
927 return obj->flags_.redundant_cut_valid_;
928 }
929
setParallelValid(bool parallel_valid)930 void dbTechLayerCutEnclosureRule::setParallelValid(bool parallel_valid)
931 {
932 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
933
934 obj->flags_.parallel_valid_ = parallel_valid;
935 }
936
isParallelValid() const937 bool dbTechLayerCutEnclosureRule::isParallelValid() const
938 {
939 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
940
941 return obj->flags_.parallel_valid_;
942 }
943
setSecondParallelValid(bool second_parallel_valid)944 void dbTechLayerCutEnclosureRule::setSecondParallelValid(
945 bool second_parallel_valid)
946 {
947 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
948
949 obj->flags_.second_parallel_valid = second_parallel_valid;
950 }
951
isSecondParallelValid() const952 bool dbTechLayerCutEnclosureRule::isSecondParallelValid() const
953 {
954 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
955
956 return obj->flags_.second_parallel_valid;
957 }
958
setSecondParWithinValid(bool second_par_within_valid)959 void dbTechLayerCutEnclosureRule::setSecondParWithinValid(
960 bool second_par_within_valid)
961 {
962 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
963
964 obj->flags_.second_par_within_valid_ = second_par_within_valid;
965 }
966
isSecondParWithinValid() const967 bool dbTechLayerCutEnclosureRule::isSecondParWithinValid() const
968 {
969 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
970
971 return obj->flags_.second_par_within_valid_;
972 }
973
setBelowEnclosureValid(bool below_enclosure_valid)974 void dbTechLayerCutEnclosureRule::setBelowEnclosureValid(
975 bool below_enclosure_valid)
976 {
977 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
978
979 obj->flags_.below_enclosure_valid_ = below_enclosure_valid;
980 }
981
isBelowEnclosureValid() const982 bool dbTechLayerCutEnclosureRule::isBelowEnclosureValid() const
983 {
984 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
985
986 return obj->flags_.below_enclosure_valid_;
987 }
988
setConcaveCornersValid(bool concave_corners_valid)989 void dbTechLayerCutEnclosureRule::setConcaveCornersValid(
990 bool concave_corners_valid)
991 {
992 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
993
994 obj->flags_.concave_corners_valid_ = concave_corners_valid;
995 }
996
isConcaveCornersValid() const997 bool dbTechLayerCutEnclosureRule::isConcaveCornersValid() const
998 {
999 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
1000
1001 return obj->flags_.concave_corners_valid_;
1002 }
1003
1004 // User Code Begin dbTechLayerCutEnclosureRulePublicMethods
setType(ENC_TYPE type)1005 void dbTechLayerCutEnclosureRule::setType(ENC_TYPE type)
1006 {
1007 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
1008
1009 obj->flags_.type_ = (uint) type;
1010 }
1011
getType() const1012 dbTechLayerCutEnclosureRule::ENC_TYPE dbTechLayerCutEnclosureRule::getType()
1013 const
1014 {
1015 _dbTechLayerCutEnclosureRule* obj = (_dbTechLayerCutEnclosureRule*) this;
1016
1017 return (dbTechLayerCutEnclosureRule::ENC_TYPE) obj->flags_.type_;
1018 }
1019
create(dbTechLayer * _layer)1020 dbTechLayerCutEnclosureRule* dbTechLayerCutEnclosureRule::create(
1021 dbTechLayer* _layer)
1022 {
1023 _dbTechLayer* layer = (_dbTechLayer*) _layer;
1024 _dbTechLayerCutEnclosureRule* newrule = layer->cut_enc_rules_tbl_->create();
1025 return ((dbTechLayerCutEnclosureRule*) newrule);
1026 }
1027
1028 dbTechLayerCutEnclosureRule*
getTechLayerCutEnclosureRule(dbTechLayer * inly,uint dbid)1029 dbTechLayerCutEnclosureRule::getTechLayerCutEnclosureRule(dbTechLayer* inly,
1030 uint dbid)
1031 {
1032 _dbTechLayer* layer = (_dbTechLayer*) inly;
1033 return (dbTechLayerCutEnclosureRule*) layer->cut_enc_rules_tbl_->getPtr(dbid);
1034 }
destroy(dbTechLayerCutEnclosureRule * rule)1035 void dbTechLayerCutEnclosureRule::destroy(dbTechLayerCutEnclosureRule* rule)
1036 {
1037 _dbTechLayer* layer = (_dbTechLayer*) rule->getImpl()->getOwner();
1038 dbProperty::destroyProperties(rule);
1039 layer->cut_enc_rules_tbl_->destroy((_dbTechLayerCutEnclosureRule*) rule);
1040 }
1041 // User Code End dbTechLayerCutEnclosureRulePublicMethods
1042 } // namespace odb
1043 // Generator Code End Cpp
1044