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 "dbTechLayerSpacingEolRule.h"
35
36 #include "db.h"
37 #include "dbDatabase.h"
38 #include "dbDiff.hpp"
39 #include "dbTable.h"
40 #include "dbTable.hpp"
41
42 // User Code Begin Includes
43 #include "dbTech.h"
44 #include "dbTechLayer.h"
45 // User Code End Includes
46 namespace odb {
47
48 template class dbTable<_dbTechLayerSpacingEolRule>;
49
operator ==(const _dbTechLayerSpacingEolRule & rhs) const50 bool _dbTechLayerSpacingEolRule::operator==(
51 const _dbTechLayerSpacingEolRule& rhs) const
52 {
53 if (flags_.exact_width_valid_ != rhs.flags_.exact_width_valid_)
54 return false;
55
56 if (flags_.wrong_dir_spacing_valid_ != rhs.flags_.wrong_dir_spacing_valid_)
57 return false;
58
59 if (flags_.opposite_width_valid_ != rhs.flags_.opposite_width_valid_)
60 return false;
61
62 if (flags_.within_valid_ != rhs.flags_.within_valid_)
63 return false;
64
65 if (flags_.wrong_dir_within_valid_ != rhs.flags_.wrong_dir_within_valid_)
66 return false;
67
68 if (flags_.same_mask_valid_ != rhs.flags_.same_mask_valid_)
69 return false;
70
71 if (flags_.except_exact_width_valid_ != rhs.flags_.except_exact_width_valid_)
72 return false;
73
74 if (flags_.fill_concave_corner_valid_
75 != rhs.flags_.fill_concave_corner_valid_)
76 return false;
77
78 if (flags_.withcut_valid_ != rhs.flags_.withcut_valid_)
79 return false;
80
81 if (flags_.cut_class_valid_ != rhs.flags_.cut_class_valid_)
82 return false;
83
84 if (flags_.with_cut_above_valid_ != rhs.flags_.with_cut_above_valid_)
85 return false;
86
87 if (flags_.enclosure_end_valid_ != rhs.flags_.enclosure_end_valid_)
88 return false;
89
90 if (flags_.enclosure_end_within_valid_
91 != rhs.flags_.enclosure_end_within_valid_)
92 return false;
93
94 if (flags_.end_prl_spacing_valid_ != rhs.flags_.end_prl_spacing_valid_)
95 return false;
96
97 if (flags_.prl_valid_ != rhs.flags_.prl_valid_)
98 return false;
99
100 if (flags_.end_to_end_valid_ != rhs.flags_.end_to_end_valid_)
101 return false;
102
103 if (flags_.cut_spaces_valid_ != rhs.flags_.cut_spaces_valid_)
104 return false;
105
106 if (flags_.extension_valid_ != rhs.flags_.extension_valid_)
107 return false;
108
109 if (flags_.wrong_dir_extension_valid_
110 != rhs.flags_.wrong_dir_extension_valid_)
111 return false;
112
113 if (flags_.other_end_width_valid_ != rhs.flags_.other_end_width_valid_)
114 return false;
115
116 if (flags_.max_length_valid_ != rhs.flags_.max_length_valid_)
117 return false;
118
119 if (flags_.min_length_valid_ != rhs.flags_.min_length_valid_)
120 return false;
121
122 if (flags_.two_sides_valid_ != rhs.flags_.two_sides_valid_)
123 return false;
124
125 if (flags_.equal_rect_width_valid_ != rhs.flags_.equal_rect_width_valid_)
126 return false;
127
128 if (flags_.parallel_edge_valid_ != rhs.flags_.parallel_edge_valid_)
129 return false;
130
131 if (flags_.subtract_eol_width_valid_ != rhs.flags_.subtract_eol_width_valid_)
132 return false;
133
134 if (flags_.par_prl_valid_ != rhs.flags_.par_prl_valid_)
135 return false;
136
137 if (flags_.par_min_length_valid_ != rhs.flags_.par_min_length_valid_)
138 return false;
139
140 if (flags_.two_edges_valid_ != rhs.flags_.two_edges_valid_)
141 return false;
142
143 if (flags_.same_metal_valid_ != rhs.flags_.same_metal_valid_)
144 return false;
145
146 if (flags_.non_eol_corner_only_valid_
147 != rhs.flags_.non_eol_corner_only_valid_)
148 return false;
149
150 if (flags_.parallel_same_mask_valid_ != rhs.flags_.parallel_same_mask_valid_)
151 return false;
152
153 if (flags_.enclose_cut_valid_ != rhs.flags_.enclose_cut_valid_)
154 return false;
155
156 if (flags_.below_valid_ != rhs.flags_.below_valid_)
157 return false;
158
159 if (flags_.above_valid_ != rhs.flags_.above_valid_)
160 return false;
161
162 if (flags_.cut_spacing_valid_ != rhs.flags_.cut_spacing_valid_)
163 return false;
164
165 if (flags_.all_cuts_valid_ != rhs.flags_.all_cuts_valid_)
166 return false;
167
168 if (flags_.to_concave_corner_valid_ != rhs.flags_.to_concave_corner_valid_)
169 return false;
170
171 if (flags_.min_adjacent_length_valid_
172 != rhs.flags_.min_adjacent_length_valid_)
173 return false;
174
175 if (flags_.two_min_adj_length_valid_ != rhs.flags_.two_min_adj_length_valid_)
176 return false;
177
178 if (flags_.to_notch_length_valid_ != rhs.flags_.to_notch_length_valid_)
179 return false;
180
181 if (eol_space_ != rhs.eol_space_)
182 return false;
183
184 if (eol_width_ != rhs.eol_width_)
185 return false;
186
187 if (wrong_dir_space_ != rhs.wrong_dir_space_)
188 return false;
189
190 if (opposite_width_ != rhs.opposite_width_)
191 return false;
192
193 if (eol_within_ != rhs.eol_within_)
194 return false;
195
196 if (wrong_dir_within_ != rhs.wrong_dir_within_)
197 return false;
198
199 if (exact_width_ != rhs.exact_width_)
200 return false;
201
202 if (other_width_ != rhs.other_width_)
203 return false;
204
205 if (fill_triangle_ != rhs.fill_triangle_)
206 return false;
207
208 if (cut_class_ != rhs.cut_class_)
209 return false;
210
211 if (with_cut_space_ != rhs.with_cut_space_)
212 return false;
213
214 if (enclosure_end_width_ != rhs.enclosure_end_width_)
215 return false;
216
217 if (enclosure_end_within_ != rhs.enclosure_end_within_)
218 return false;
219
220 if (end_prl_space_ != rhs.end_prl_space_)
221 return false;
222
223 if (end_prl_ != rhs.end_prl_)
224 return false;
225
226 if (end_to_end_space_ != rhs.end_to_end_space_)
227 return false;
228
229 if (one_cut_space_ != rhs.one_cut_space_)
230 return false;
231
232 if (two_cut_space_ != rhs.two_cut_space_)
233 return false;
234
235 if (extension_ != rhs.extension_)
236 return false;
237
238 if (wrong_dir_extension_ != rhs.wrong_dir_extension_)
239 return false;
240
241 if (other_end_width_ != rhs.other_end_width_)
242 return false;
243
244 if (max_length_ != rhs.max_length_)
245 return false;
246
247 if (min_length_ != rhs.min_length_)
248 return false;
249
250 if (par_space_ != rhs.par_space_)
251 return false;
252
253 if (par_within_ != rhs.par_within_)
254 return false;
255
256 if (par_prl_ != rhs.par_prl_)
257 return false;
258
259 if (par_min_length_ != rhs.par_min_length_)
260 return false;
261
262 if (enclose_dist_ != rhs.enclose_dist_)
263 return false;
264
265 if (cut_to_metal_space_ != rhs.cut_to_metal_space_)
266 return false;
267
268 if (min_adj_length_ != rhs.min_adj_length_)
269 return false;
270
271 if (min_adj_length1_ != rhs.min_adj_length1_)
272 return false;
273
274 if (min_adj_length2_ != rhs.min_adj_length2_)
275 return false;
276
277 if (notch_length_ != rhs.notch_length_)
278 return false;
279
280 // User Code Begin ==
281 // User Code End ==
282 return true;
283 }
operator <(const _dbTechLayerSpacingEolRule & rhs) const284 bool _dbTechLayerSpacingEolRule::operator<(
285 const _dbTechLayerSpacingEolRule& rhs) const
286 {
287 // User Code Begin <
288 // User Code End <
289 return true;
290 }
differences(dbDiff & diff,const char * field,const _dbTechLayerSpacingEolRule & rhs) const291 void _dbTechLayerSpacingEolRule::differences(
292 dbDiff& diff,
293 const char* field,
294 const _dbTechLayerSpacingEolRule& rhs) const
295 {
296 DIFF_BEGIN
297
298 DIFF_FIELD(flags_.exact_width_valid_);
299 DIFF_FIELD(flags_.wrong_dir_spacing_valid_);
300 DIFF_FIELD(flags_.opposite_width_valid_);
301 DIFF_FIELD(flags_.within_valid_);
302 DIFF_FIELD(flags_.wrong_dir_within_valid_);
303 DIFF_FIELD(flags_.same_mask_valid_);
304 DIFF_FIELD(flags_.except_exact_width_valid_);
305 DIFF_FIELD(flags_.fill_concave_corner_valid_);
306 DIFF_FIELD(flags_.withcut_valid_);
307 DIFF_FIELD(flags_.cut_class_valid_);
308 DIFF_FIELD(flags_.with_cut_above_valid_);
309 DIFF_FIELD(flags_.enclosure_end_valid_);
310 DIFF_FIELD(flags_.enclosure_end_within_valid_);
311 DIFF_FIELD(flags_.end_prl_spacing_valid_);
312 DIFF_FIELD(flags_.prl_valid_);
313 DIFF_FIELD(flags_.end_to_end_valid_);
314 DIFF_FIELD(flags_.cut_spaces_valid_);
315 DIFF_FIELD(flags_.extension_valid_);
316 DIFF_FIELD(flags_.wrong_dir_extension_valid_);
317 DIFF_FIELD(flags_.other_end_width_valid_);
318 DIFF_FIELD(flags_.max_length_valid_);
319 DIFF_FIELD(flags_.min_length_valid_);
320 DIFF_FIELD(flags_.two_sides_valid_);
321 DIFF_FIELD(flags_.equal_rect_width_valid_);
322 DIFF_FIELD(flags_.parallel_edge_valid_);
323 DIFF_FIELD(flags_.subtract_eol_width_valid_);
324 DIFF_FIELD(flags_.par_prl_valid_);
325 DIFF_FIELD(flags_.par_min_length_valid_);
326 DIFF_FIELD(flags_.two_edges_valid_);
327 DIFF_FIELD(flags_.same_metal_valid_);
328 DIFF_FIELD(flags_.non_eol_corner_only_valid_);
329 DIFF_FIELD(flags_.parallel_same_mask_valid_);
330 DIFF_FIELD(flags_.enclose_cut_valid_);
331 DIFF_FIELD(flags_.below_valid_);
332 DIFF_FIELD(flags_.above_valid_);
333 DIFF_FIELD(flags_.cut_spacing_valid_);
334 DIFF_FIELD(flags_.all_cuts_valid_);
335 DIFF_FIELD(flags_.to_concave_corner_valid_);
336 DIFF_FIELD(flags_.min_adjacent_length_valid_);
337 DIFF_FIELD(flags_.two_min_adj_length_valid_);
338 DIFF_FIELD(flags_.to_notch_length_valid_);
339 DIFF_FIELD(eol_space_);
340 DIFF_FIELD(eol_width_);
341 DIFF_FIELD(wrong_dir_space_);
342 DIFF_FIELD(opposite_width_);
343 DIFF_FIELD(eol_within_);
344 DIFF_FIELD(wrong_dir_within_);
345 DIFF_FIELD(exact_width_);
346 DIFF_FIELD(other_width_);
347 DIFF_FIELD(fill_triangle_);
348 DIFF_FIELD(cut_class_);
349 DIFF_FIELD(with_cut_space_);
350 DIFF_FIELD(enclosure_end_width_);
351 DIFF_FIELD(enclosure_end_within_);
352 DIFF_FIELD(end_prl_space_);
353 DIFF_FIELD(end_prl_);
354 DIFF_FIELD(end_to_end_space_);
355 DIFF_FIELD(one_cut_space_);
356 DIFF_FIELD(two_cut_space_);
357 DIFF_FIELD(extension_);
358 DIFF_FIELD(wrong_dir_extension_);
359 DIFF_FIELD(other_end_width_);
360 DIFF_FIELD(max_length_);
361 DIFF_FIELD(min_length_);
362 DIFF_FIELD(par_space_);
363 DIFF_FIELD(par_within_);
364 DIFF_FIELD(par_prl_);
365 DIFF_FIELD(par_min_length_);
366 DIFF_FIELD(enclose_dist_);
367 DIFF_FIELD(cut_to_metal_space_);
368 DIFF_FIELD(min_adj_length_);
369 DIFF_FIELD(min_adj_length1_);
370 DIFF_FIELD(min_adj_length2_);
371 DIFF_FIELD(notch_length_);
372 // User Code Begin Differences
373 // User Code End Differences
374 DIFF_END
375 }
out(dbDiff & diff,char side,const char * field) const376 void _dbTechLayerSpacingEolRule::out(dbDiff& diff,
377 char side,
378 const char* field) const
379 {
380 DIFF_OUT_BEGIN
381 DIFF_OUT_FIELD(flags_.exact_width_valid_);
382 DIFF_OUT_FIELD(flags_.wrong_dir_spacing_valid_);
383 DIFF_OUT_FIELD(flags_.opposite_width_valid_);
384 DIFF_OUT_FIELD(flags_.within_valid_);
385 DIFF_OUT_FIELD(flags_.wrong_dir_within_valid_);
386 DIFF_OUT_FIELD(flags_.same_mask_valid_);
387 DIFF_OUT_FIELD(flags_.except_exact_width_valid_);
388 DIFF_OUT_FIELD(flags_.fill_concave_corner_valid_);
389 DIFF_OUT_FIELD(flags_.withcut_valid_);
390 DIFF_OUT_FIELD(flags_.cut_class_valid_);
391 DIFF_OUT_FIELD(flags_.with_cut_above_valid_);
392 DIFF_OUT_FIELD(flags_.enclosure_end_valid_);
393 DIFF_OUT_FIELD(flags_.enclosure_end_within_valid_);
394 DIFF_OUT_FIELD(flags_.end_prl_spacing_valid_);
395 DIFF_OUT_FIELD(flags_.prl_valid_);
396 DIFF_OUT_FIELD(flags_.end_to_end_valid_);
397 DIFF_OUT_FIELD(flags_.cut_spaces_valid_);
398 DIFF_OUT_FIELD(flags_.extension_valid_);
399 DIFF_OUT_FIELD(flags_.wrong_dir_extension_valid_);
400 DIFF_OUT_FIELD(flags_.other_end_width_valid_);
401 DIFF_OUT_FIELD(flags_.max_length_valid_);
402 DIFF_OUT_FIELD(flags_.min_length_valid_);
403 DIFF_OUT_FIELD(flags_.two_sides_valid_);
404 DIFF_OUT_FIELD(flags_.equal_rect_width_valid_);
405 DIFF_OUT_FIELD(flags_.parallel_edge_valid_);
406 DIFF_OUT_FIELD(flags_.subtract_eol_width_valid_);
407 DIFF_OUT_FIELD(flags_.par_prl_valid_);
408 DIFF_OUT_FIELD(flags_.par_min_length_valid_);
409 DIFF_OUT_FIELD(flags_.two_edges_valid_);
410 DIFF_OUT_FIELD(flags_.same_metal_valid_);
411 DIFF_OUT_FIELD(flags_.non_eol_corner_only_valid_);
412 DIFF_OUT_FIELD(flags_.parallel_same_mask_valid_);
413 DIFF_OUT_FIELD(flags_.enclose_cut_valid_);
414 DIFF_OUT_FIELD(flags_.below_valid_);
415 DIFF_OUT_FIELD(flags_.above_valid_);
416 DIFF_OUT_FIELD(flags_.cut_spacing_valid_);
417 DIFF_OUT_FIELD(flags_.all_cuts_valid_);
418 DIFF_OUT_FIELD(flags_.to_concave_corner_valid_);
419 DIFF_OUT_FIELD(flags_.min_adjacent_length_valid_);
420 DIFF_OUT_FIELD(flags_.two_min_adj_length_valid_);
421 DIFF_OUT_FIELD(flags_.to_notch_length_valid_);
422 DIFF_OUT_FIELD(eol_space_);
423 DIFF_OUT_FIELD(eol_width_);
424 DIFF_OUT_FIELD(wrong_dir_space_);
425 DIFF_OUT_FIELD(opposite_width_);
426 DIFF_OUT_FIELD(eol_within_);
427 DIFF_OUT_FIELD(wrong_dir_within_);
428 DIFF_OUT_FIELD(exact_width_);
429 DIFF_OUT_FIELD(other_width_);
430 DIFF_OUT_FIELD(fill_triangle_);
431 DIFF_OUT_FIELD(cut_class_);
432 DIFF_OUT_FIELD(with_cut_space_);
433 DIFF_OUT_FIELD(enclosure_end_width_);
434 DIFF_OUT_FIELD(enclosure_end_within_);
435 DIFF_OUT_FIELD(end_prl_space_);
436 DIFF_OUT_FIELD(end_prl_);
437 DIFF_OUT_FIELD(end_to_end_space_);
438 DIFF_OUT_FIELD(one_cut_space_);
439 DIFF_OUT_FIELD(two_cut_space_);
440 DIFF_OUT_FIELD(extension_);
441 DIFF_OUT_FIELD(wrong_dir_extension_);
442 DIFF_OUT_FIELD(other_end_width_);
443 DIFF_OUT_FIELD(max_length_);
444 DIFF_OUT_FIELD(min_length_);
445 DIFF_OUT_FIELD(par_space_);
446 DIFF_OUT_FIELD(par_within_);
447 DIFF_OUT_FIELD(par_prl_);
448 DIFF_OUT_FIELD(par_min_length_);
449 DIFF_OUT_FIELD(enclose_dist_);
450 DIFF_OUT_FIELD(cut_to_metal_space_);
451 DIFF_OUT_FIELD(min_adj_length_);
452 DIFF_OUT_FIELD(min_adj_length1_);
453 DIFF_OUT_FIELD(min_adj_length2_);
454 DIFF_OUT_FIELD(notch_length_);
455
456 // User Code Begin Out
457 // User Code End Out
458 DIFF_END
459 }
_dbTechLayerSpacingEolRule(_dbDatabase * db)460 _dbTechLayerSpacingEolRule::_dbTechLayerSpacingEolRule(_dbDatabase* db)
461 {
462 uint64_t* flags__bit_field = (uint64_t*) &flags_;
463 *flags__bit_field = 0;
464 eol_space_ = 0;
465 eol_width_ = 0;
466 wrong_dir_space_ = 0;
467 opposite_width_ = 0;
468 eol_within_ = 0;
469 wrong_dir_within_ = 0;
470 exact_width_ = 0;
471 other_width_ = 0;
472 fill_triangle_ = 0;
473 cut_class_ = 0;
474 with_cut_space_ = 0;
475 enclosure_end_width_ = 0;
476 enclosure_end_within_ = 0;
477 end_prl_space_ = 0;
478 end_prl_ = 0;
479 end_to_end_space_ = 0;
480 one_cut_space_ = 0;
481 two_cut_space_ = 0;
482 extension_ = 0;
483 wrong_dir_extension_ = 0;
484 other_end_width_ = 0;
485 max_length_ = 0;
486 min_length_ = 0;
487 par_space_ = 0;
488 par_within_ = 0;
489 par_prl_ = 0;
490 par_min_length_ = 0;
491 enclose_dist_ = 0;
492 cut_to_metal_space_ = 0;
493 min_adj_length_ = 0;
494 min_adj_length1_ = 0;
495 min_adj_length2_ = 0;
496 notch_length_ = 0;
497 // User Code Begin Constructor
498 eol_space_ = 0;
499 eol_width_ = 0;
500 wrong_dir_space_ = 0;
501 opposite_width_ = 0;
502 eol_within_ = 0;
503 wrong_dir_within_ = 0;
504 exact_width_ = 0;
505 other_width_ = 0;
506 fill_triangle_ = 0;
507 cut_class_ = 0;
508 with_cut_space_ = 0;
509 enclosure_end_width_ = 0;
510 enclosure_end_within_ = 0;
511 end_prl_space_ = 0;
512 end_prl_ = 0;
513 end_to_end_space_ = 0;
514 one_cut_space_ = 0;
515 two_cut_space_ = 0;
516 extension_ = 0;
517 wrong_dir_extension_ = 0;
518 other_end_width_ = 0;
519 max_length_ = 0;
520 min_length_ = 0;
521 par_space_ = 0;
522 par_within_ = 0;
523 par_prl_ = 0;
524 par_min_length_ = 0;
525 enclose_dist_ = 0;
526 cut_to_metal_space_ = 0;
527 min_adj_length_ = 0;
528 min_adj_length1_ = 0;
529 min_adj_length2_ = 0;
530 notch_length_ = 0;
531 // User Code End Constructor
532 }
_dbTechLayerSpacingEolRule(_dbDatabase * db,const _dbTechLayerSpacingEolRule & r)533 _dbTechLayerSpacingEolRule::_dbTechLayerSpacingEolRule(
534 _dbDatabase* db,
535 const _dbTechLayerSpacingEolRule& r)
536 {
537 flags_.exact_width_valid_ = r.flags_.exact_width_valid_;
538 flags_.wrong_dir_spacing_valid_ = r.flags_.wrong_dir_spacing_valid_;
539 flags_.opposite_width_valid_ = r.flags_.opposite_width_valid_;
540 flags_.within_valid_ = r.flags_.within_valid_;
541 flags_.wrong_dir_within_valid_ = r.flags_.wrong_dir_within_valid_;
542 flags_.same_mask_valid_ = r.flags_.same_mask_valid_;
543 flags_.except_exact_width_valid_ = r.flags_.except_exact_width_valid_;
544 flags_.fill_concave_corner_valid_ = r.flags_.fill_concave_corner_valid_;
545 flags_.withcut_valid_ = r.flags_.withcut_valid_;
546 flags_.cut_class_valid_ = r.flags_.cut_class_valid_;
547 flags_.with_cut_above_valid_ = r.flags_.with_cut_above_valid_;
548 flags_.enclosure_end_valid_ = r.flags_.enclosure_end_valid_;
549 flags_.enclosure_end_within_valid_ = r.flags_.enclosure_end_within_valid_;
550 flags_.end_prl_spacing_valid_ = r.flags_.end_prl_spacing_valid_;
551 flags_.prl_valid_ = r.flags_.prl_valid_;
552 flags_.end_to_end_valid_ = r.flags_.end_to_end_valid_;
553 flags_.cut_spaces_valid_ = r.flags_.cut_spaces_valid_;
554 flags_.extension_valid_ = r.flags_.extension_valid_;
555 flags_.wrong_dir_extension_valid_ = r.flags_.wrong_dir_extension_valid_;
556 flags_.other_end_width_valid_ = r.flags_.other_end_width_valid_;
557 flags_.max_length_valid_ = r.flags_.max_length_valid_;
558 flags_.min_length_valid_ = r.flags_.min_length_valid_;
559 flags_.two_sides_valid_ = r.flags_.two_sides_valid_;
560 flags_.equal_rect_width_valid_ = r.flags_.equal_rect_width_valid_;
561 flags_.parallel_edge_valid_ = r.flags_.parallel_edge_valid_;
562 flags_.subtract_eol_width_valid_ = r.flags_.subtract_eol_width_valid_;
563 flags_.par_prl_valid_ = r.flags_.par_prl_valid_;
564 flags_.par_min_length_valid_ = r.flags_.par_min_length_valid_;
565 flags_.two_edges_valid_ = r.flags_.two_edges_valid_;
566 flags_.same_metal_valid_ = r.flags_.same_metal_valid_;
567 flags_.non_eol_corner_only_valid_ = r.flags_.non_eol_corner_only_valid_;
568 flags_.parallel_same_mask_valid_ = r.flags_.parallel_same_mask_valid_;
569 flags_.enclose_cut_valid_ = r.flags_.enclose_cut_valid_;
570 flags_.below_valid_ = r.flags_.below_valid_;
571 flags_.above_valid_ = r.flags_.above_valid_;
572 flags_.cut_spacing_valid_ = r.flags_.cut_spacing_valid_;
573 flags_.all_cuts_valid_ = r.flags_.all_cuts_valid_;
574 flags_.to_concave_corner_valid_ = r.flags_.to_concave_corner_valid_;
575 flags_.min_adjacent_length_valid_ = r.flags_.min_adjacent_length_valid_;
576 flags_.two_min_adj_length_valid_ = r.flags_.two_min_adj_length_valid_;
577 flags_.to_notch_length_valid_ = r.flags_.to_notch_length_valid_;
578 flags_.spare_bits_ = r.flags_.spare_bits_;
579 eol_space_ = r.eol_space_;
580 eol_width_ = r.eol_width_;
581 wrong_dir_space_ = r.wrong_dir_space_;
582 opposite_width_ = r.opposite_width_;
583 eol_within_ = r.eol_within_;
584 wrong_dir_within_ = r.wrong_dir_within_;
585 exact_width_ = r.exact_width_;
586 other_width_ = r.other_width_;
587 fill_triangle_ = r.fill_triangle_;
588 cut_class_ = r.cut_class_;
589 with_cut_space_ = r.with_cut_space_;
590 enclosure_end_width_ = r.enclosure_end_width_;
591 enclosure_end_within_ = r.enclosure_end_within_;
592 end_prl_space_ = r.end_prl_space_;
593 end_prl_ = r.end_prl_;
594 end_to_end_space_ = r.end_to_end_space_;
595 one_cut_space_ = r.one_cut_space_;
596 two_cut_space_ = r.two_cut_space_;
597 extension_ = r.extension_;
598 wrong_dir_extension_ = r.wrong_dir_extension_;
599 other_end_width_ = r.other_end_width_;
600 max_length_ = r.max_length_;
601 min_length_ = r.min_length_;
602 par_space_ = r.par_space_;
603 par_within_ = r.par_within_;
604 par_prl_ = r.par_prl_;
605 par_min_length_ = r.par_min_length_;
606 enclose_dist_ = r.enclose_dist_;
607 cut_to_metal_space_ = r.cut_to_metal_space_;
608 min_adj_length_ = r.min_adj_length_;
609 min_adj_length1_ = r.min_adj_length1_;
610 min_adj_length2_ = r.min_adj_length2_;
611 notch_length_ = r.notch_length_;
612 // User Code Begin CopyConstructor
613 // User Code End CopyConstructor
614 }
615
operator >>(dbIStream & stream,_dbTechLayerSpacingEolRule & obj)616 dbIStream& operator>>(dbIStream& stream, _dbTechLayerSpacingEolRule& obj)
617 {
618 uint64_t* flags__bit_field = (uint64_t*) &obj.flags_;
619 stream >> *flags__bit_field;
620 stream >> obj.eol_space_;
621 stream >> obj.eol_width_;
622 stream >> obj.wrong_dir_space_;
623 stream >> obj.opposite_width_;
624 stream >> obj.eol_within_;
625 stream >> obj.wrong_dir_within_;
626 stream >> obj.exact_width_;
627 stream >> obj.other_width_;
628 stream >> obj.fill_triangle_;
629 stream >> obj.cut_class_;
630 stream >> obj.with_cut_space_;
631 stream >> obj.enclosure_end_width_;
632 stream >> obj.enclosure_end_within_;
633 stream >> obj.end_prl_space_;
634 stream >> obj.end_prl_;
635 stream >> obj.end_to_end_space_;
636 stream >> obj.one_cut_space_;
637 stream >> obj.two_cut_space_;
638 stream >> obj.extension_;
639 stream >> obj.wrong_dir_extension_;
640 stream >> obj.other_end_width_;
641 stream >> obj.max_length_;
642 stream >> obj.min_length_;
643 stream >> obj.par_space_;
644 stream >> obj.par_within_;
645 stream >> obj.par_prl_;
646 stream >> obj.par_min_length_;
647 stream >> obj.enclose_dist_;
648 stream >> obj.cut_to_metal_space_;
649 stream >> obj.min_adj_length_;
650 stream >> obj.min_adj_length1_;
651 stream >> obj.min_adj_length2_;
652 stream >> obj.notch_length_;
653 // User Code Begin >>
654 // User Code End >>
655 return stream;
656 }
operator <<(dbOStream & stream,const _dbTechLayerSpacingEolRule & obj)657 dbOStream& operator<<(dbOStream& stream, const _dbTechLayerSpacingEolRule& obj)
658 {
659 uint64_t* flags__bit_field = (uint64_t*) &obj.flags_;
660 stream << *flags__bit_field;
661 stream << obj.eol_space_;
662 stream << obj.eol_width_;
663 stream << obj.wrong_dir_space_;
664 stream << obj.opposite_width_;
665 stream << obj.eol_within_;
666 stream << obj.wrong_dir_within_;
667 stream << obj.exact_width_;
668 stream << obj.other_width_;
669 stream << obj.fill_triangle_;
670 stream << obj.cut_class_;
671 stream << obj.with_cut_space_;
672 stream << obj.enclosure_end_width_;
673 stream << obj.enclosure_end_within_;
674 stream << obj.end_prl_space_;
675 stream << obj.end_prl_;
676 stream << obj.end_to_end_space_;
677 stream << obj.one_cut_space_;
678 stream << obj.two_cut_space_;
679 stream << obj.extension_;
680 stream << obj.wrong_dir_extension_;
681 stream << obj.other_end_width_;
682 stream << obj.max_length_;
683 stream << obj.min_length_;
684 stream << obj.par_space_;
685 stream << obj.par_within_;
686 stream << obj.par_prl_;
687 stream << obj.par_min_length_;
688 stream << obj.enclose_dist_;
689 stream << obj.cut_to_metal_space_;
690 stream << obj.min_adj_length_;
691 stream << obj.min_adj_length1_;
692 stream << obj.min_adj_length2_;
693 stream << obj.notch_length_;
694 // User Code Begin <<
695 // User Code End <<
696 return stream;
697 }
698
~_dbTechLayerSpacingEolRule()699 _dbTechLayerSpacingEolRule::~_dbTechLayerSpacingEolRule()
700 {
701 // User Code Begin Destructor
702 // User Code End Destructor
703 }
704
705 // User Code Begin PrivateMethods
706 // User Code End PrivateMethods
707
708 ////////////////////////////////////////////////////////////////////
709 //
710 // dbTechLayerSpacingEolRule - Methods
711 //
712 ////////////////////////////////////////////////////////////////////
713
setEolSpace(int eol_space)714 void dbTechLayerSpacingEolRule::setEolSpace(int eol_space)
715 {
716 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
717
718 obj->eol_space_ = eol_space;
719 }
720
getEolSpace() const721 int dbTechLayerSpacingEolRule::getEolSpace() const
722 {
723 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
724 return obj->eol_space_;
725 }
726
setEolWidth(int eol_width)727 void dbTechLayerSpacingEolRule::setEolWidth(int eol_width)
728 {
729 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
730
731 obj->eol_width_ = eol_width;
732 }
733
getEolWidth() const734 int dbTechLayerSpacingEolRule::getEolWidth() const
735 {
736 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
737 return obj->eol_width_;
738 }
739
setWrongDirSpace(int wrong_dir_space)740 void dbTechLayerSpacingEolRule::setWrongDirSpace(int wrong_dir_space)
741 {
742 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
743
744 obj->wrong_dir_space_ = wrong_dir_space;
745 }
746
getWrongDirSpace() const747 int dbTechLayerSpacingEolRule::getWrongDirSpace() const
748 {
749 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
750 return obj->wrong_dir_space_;
751 }
752
setOppositeWidth(int opposite_width)753 void dbTechLayerSpacingEolRule::setOppositeWidth(int opposite_width)
754 {
755 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
756
757 obj->opposite_width_ = opposite_width;
758 }
759
getOppositeWidth() const760 int dbTechLayerSpacingEolRule::getOppositeWidth() const
761 {
762 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
763 return obj->opposite_width_;
764 }
765
setEolWithin(int eol_within)766 void dbTechLayerSpacingEolRule::setEolWithin(int eol_within)
767 {
768 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
769
770 obj->eol_within_ = eol_within;
771 }
772
getEolWithin() const773 int dbTechLayerSpacingEolRule::getEolWithin() const
774 {
775 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
776 return obj->eol_within_;
777 }
778
setWrongDirWithin(int wrong_dir_within)779 void dbTechLayerSpacingEolRule::setWrongDirWithin(int wrong_dir_within)
780 {
781 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
782
783 obj->wrong_dir_within_ = wrong_dir_within;
784 }
785
getWrongDirWithin() const786 int dbTechLayerSpacingEolRule::getWrongDirWithin() const
787 {
788 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
789 return obj->wrong_dir_within_;
790 }
791
setExactWidth(int exact_width)792 void dbTechLayerSpacingEolRule::setExactWidth(int exact_width)
793 {
794 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
795
796 obj->exact_width_ = exact_width;
797 }
798
getExactWidth() const799 int dbTechLayerSpacingEolRule::getExactWidth() const
800 {
801 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
802 return obj->exact_width_;
803 }
804
setOtherWidth(int other_width)805 void dbTechLayerSpacingEolRule::setOtherWidth(int other_width)
806 {
807 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
808
809 obj->other_width_ = other_width;
810 }
811
getOtherWidth() const812 int dbTechLayerSpacingEolRule::getOtherWidth() const
813 {
814 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
815 return obj->other_width_;
816 }
817
setFillTriangle(int fill_triangle)818 void dbTechLayerSpacingEolRule::setFillTriangle(int fill_triangle)
819 {
820 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
821
822 obj->fill_triangle_ = fill_triangle;
823 }
824
getFillTriangle() const825 int dbTechLayerSpacingEolRule::getFillTriangle() const
826 {
827 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
828 return obj->fill_triangle_;
829 }
830
setCutClass(int cut_class)831 void dbTechLayerSpacingEolRule::setCutClass(int cut_class)
832 {
833 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
834
835 obj->cut_class_ = cut_class;
836 }
837
getCutClass() const838 int dbTechLayerSpacingEolRule::getCutClass() const
839 {
840 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
841 return obj->cut_class_;
842 }
843
setWithCutSpace(int with_cut_space)844 void dbTechLayerSpacingEolRule::setWithCutSpace(int with_cut_space)
845 {
846 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
847
848 obj->with_cut_space_ = with_cut_space;
849 }
850
getWithCutSpace() const851 int dbTechLayerSpacingEolRule::getWithCutSpace() const
852 {
853 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
854 return obj->with_cut_space_;
855 }
856
setEnclosureEndWidth(int enclosure_end_width)857 void dbTechLayerSpacingEolRule::setEnclosureEndWidth(int enclosure_end_width)
858 {
859 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
860
861 obj->enclosure_end_width_ = enclosure_end_width;
862 }
863
getEnclosureEndWidth() const864 int dbTechLayerSpacingEolRule::getEnclosureEndWidth() const
865 {
866 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
867 return obj->enclosure_end_width_;
868 }
869
setEnclosureEndWithin(int enclosure_end_within)870 void dbTechLayerSpacingEolRule::setEnclosureEndWithin(int enclosure_end_within)
871 {
872 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
873
874 obj->enclosure_end_within_ = enclosure_end_within;
875 }
876
getEnclosureEndWithin() const877 int dbTechLayerSpacingEolRule::getEnclosureEndWithin() const
878 {
879 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
880 return obj->enclosure_end_within_;
881 }
882
setEndPrlSpace(int end_prl_space)883 void dbTechLayerSpacingEolRule::setEndPrlSpace(int end_prl_space)
884 {
885 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
886
887 obj->end_prl_space_ = end_prl_space;
888 }
889
getEndPrlSpace() const890 int dbTechLayerSpacingEolRule::getEndPrlSpace() const
891 {
892 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
893 return obj->end_prl_space_;
894 }
895
setEndPrl(int end_prl)896 void dbTechLayerSpacingEolRule::setEndPrl(int end_prl)
897 {
898 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
899
900 obj->end_prl_ = end_prl;
901 }
902
getEndPrl() const903 int dbTechLayerSpacingEolRule::getEndPrl() const
904 {
905 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
906 return obj->end_prl_;
907 }
908
setEndToEndSpace(int end_to_end_space)909 void dbTechLayerSpacingEolRule::setEndToEndSpace(int end_to_end_space)
910 {
911 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
912
913 obj->end_to_end_space_ = end_to_end_space;
914 }
915
getEndToEndSpace() const916 int dbTechLayerSpacingEolRule::getEndToEndSpace() const
917 {
918 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
919 return obj->end_to_end_space_;
920 }
921
setOneCutSpace(int one_cut_space)922 void dbTechLayerSpacingEolRule::setOneCutSpace(int one_cut_space)
923 {
924 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
925
926 obj->one_cut_space_ = one_cut_space;
927 }
928
getOneCutSpace() const929 int dbTechLayerSpacingEolRule::getOneCutSpace() const
930 {
931 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
932 return obj->one_cut_space_;
933 }
934
setTwoCutSpace(int two_cut_space)935 void dbTechLayerSpacingEolRule::setTwoCutSpace(int two_cut_space)
936 {
937 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
938
939 obj->two_cut_space_ = two_cut_space;
940 }
941
getTwoCutSpace() const942 int dbTechLayerSpacingEolRule::getTwoCutSpace() const
943 {
944 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
945 return obj->two_cut_space_;
946 }
947
setExtension(int extension)948 void dbTechLayerSpacingEolRule::setExtension(int extension)
949 {
950 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
951
952 obj->extension_ = extension;
953 }
954
getExtension() const955 int dbTechLayerSpacingEolRule::getExtension() const
956 {
957 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
958 return obj->extension_;
959 }
960
setWrongDirExtension(int wrong_dir_extension)961 void dbTechLayerSpacingEolRule::setWrongDirExtension(int wrong_dir_extension)
962 {
963 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
964
965 obj->wrong_dir_extension_ = wrong_dir_extension;
966 }
967
getWrongDirExtension() const968 int dbTechLayerSpacingEolRule::getWrongDirExtension() const
969 {
970 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
971 return obj->wrong_dir_extension_;
972 }
973
setOtherEndWidth(int other_end_width)974 void dbTechLayerSpacingEolRule::setOtherEndWidth(int other_end_width)
975 {
976 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
977
978 obj->other_end_width_ = other_end_width;
979 }
980
getOtherEndWidth() const981 int dbTechLayerSpacingEolRule::getOtherEndWidth() const
982 {
983 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
984 return obj->other_end_width_;
985 }
986
setMaxLength(int max_length)987 void dbTechLayerSpacingEolRule::setMaxLength(int max_length)
988 {
989 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
990
991 obj->max_length_ = max_length;
992 }
993
getMaxLength() const994 int dbTechLayerSpacingEolRule::getMaxLength() const
995 {
996 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
997 return obj->max_length_;
998 }
999
setMinLength(int min_length)1000 void dbTechLayerSpacingEolRule::setMinLength(int min_length)
1001 {
1002 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1003
1004 obj->min_length_ = min_length;
1005 }
1006
getMinLength() const1007 int dbTechLayerSpacingEolRule::getMinLength() const
1008 {
1009 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1010 return obj->min_length_;
1011 }
1012
setParSpace(int par_space)1013 void dbTechLayerSpacingEolRule::setParSpace(int par_space)
1014 {
1015 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1016
1017 obj->par_space_ = par_space;
1018 }
1019
getParSpace() const1020 int dbTechLayerSpacingEolRule::getParSpace() const
1021 {
1022 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1023 return obj->par_space_;
1024 }
1025
setParWithin(int par_within)1026 void dbTechLayerSpacingEolRule::setParWithin(int par_within)
1027 {
1028 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1029
1030 obj->par_within_ = par_within;
1031 }
1032
getParWithin() const1033 int dbTechLayerSpacingEolRule::getParWithin() const
1034 {
1035 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1036 return obj->par_within_;
1037 }
1038
setParPrl(int par_prl)1039 void dbTechLayerSpacingEolRule::setParPrl(int par_prl)
1040 {
1041 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1042
1043 obj->par_prl_ = par_prl;
1044 }
1045
getParPrl() const1046 int dbTechLayerSpacingEolRule::getParPrl() const
1047 {
1048 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1049 return obj->par_prl_;
1050 }
1051
setParMinLength(int par_min_length)1052 void dbTechLayerSpacingEolRule::setParMinLength(int par_min_length)
1053 {
1054 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1055
1056 obj->par_min_length_ = par_min_length;
1057 }
1058
getParMinLength() const1059 int dbTechLayerSpacingEolRule::getParMinLength() const
1060 {
1061 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1062 return obj->par_min_length_;
1063 }
1064
setEncloseDist(int enclose_dist)1065 void dbTechLayerSpacingEolRule::setEncloseDist(int enclose_dist)
1066 {
1067 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1068
1069 obj->enclose_dist_ = enclose_dist;
1070 }
1071
getEncloseDist() const1072 int dbTechLayerSpacingEolRule::getEncloseDist() const
1073 {
1074 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1075 return obj->enclose_dist_;
1076 }
1077
setCutToMetalSpace(int cut_to_metal_space)1078 void dbTechLayerSpacingEolRule::setCutToMetalSpace(int cut_to_metal_space)
1079 {
1080 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1081
1082 obj->cut_to_metal_space_ = cut_to_metal_space;
1083 }
1084
getCutToMetalSpace() const1085 int dbTechLayerSpacingEolRule::getCutToMetalSpace() const
1086 {
1087 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1088 return obj->cut_to_metal_space_;
1089 }
1090
setMinAdjLength(int min_adj_length)1091 void dbTechLayerSpacingEolRule::setMinAdjLength(int min_adj_length)
1092 {
1093 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1094
1095 obj->min_adj_length_ = min_adj_length;
1096 }
1097
getMinAdjLength() const1098 int dbTechLayerSpacingEolRule::getMinAdjLength() const
1099 {
1100 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1101 return obj->min_adj_length_;
1102 }
1103
setMinAdjLength1(int min_adj_length1)1104 void dbTechLayerSpacingEolRule::setMinAdjLength1(int min_adj_length1)
1105 {
1106 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1107
1108 obj->min_adj_length1_ = min_adj_length1;
1109 }
1110
getMinAdjLength1() const1111 int dbTechLayerSpacingEolRule::getMinAdjLength1() const
1112 {
1113 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1114 return obj->min_adj_length1_;
1115 }
1116
setMinAdjLength2(int min_adj_length2)1117 void dbTechLayerSpacingEolRule::setMinAdjLength2(int min_adj_length2)
1118 {
1119 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1120
1121 obj->min_adj_length2_ = min_adj_length2;
1122 }
1123
getMinAdjLength2() const1124 int dbTechLayerSpacingEolRule::getMinAdjLength2() const
1125 {
1126 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1127 return obj->min_adj_length2_;
1128 }
1129
setNotchLength(int notch_length)1130 void dbTechLayerSpacingEolRule::setNotchLength(int notch_length)
1131 {
1132 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1133
1134 obj->notch_length_ = notch_length;
1135 }
1136
getNotchLength() const1137 int dbTechLayerSpacingEolRule::getNotchLength() const
1138 {
1139 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1140 return obj->notch_length_;
1141 }
1142
setExactWidthValid(bool exact_width_valid)1143 void dbTechLayerSpacingEolRule::setExactWidthValid(bool exact_width_valid)
1144 {
1145 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1146
1147 obj->flags_.exact_width_valid_ = exact_width_valid;
1148 }
1149
isExactWidthValid() const1150 bool dbTechLayerSpacingEolRule::isExactWidthValid() const
1151 {
1152 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1153
1154 return obj->flags_.exact_width_valid_;
1155 }
1156
setWrongDirSpacingValid(bool wrong_dir_spacing_valid)1157 void dbTechLayerSpacingEolRule::setWrongDirSpacingValid(
1158 bool wrong_dir_spacing_valid)
1159 {
1160 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1161
1162 obj->flags_.wrong_dir_spacing_valid_ = wrong_dir_spacing_valid;
1163 }
1164
isWrongDirSpacingValid() const1165 bool dbTechLayerSpacingEolRule::isWrongDirSpacingValid() const
1166 {
1167 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1168
1169 return obj->flags_.wrong_dir_spacing_valid_;
1170 }
1171
setOppositeWidthValid(bool opposite_width_valid)1172 void dbTechLayerSpacingEolRule::setOppositeWidthValid(bool opposite_width_valid)
1173 {
1174 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1175
1176 obj->flags_.opposite_width_valid_ = opposite_width_valid;
1177 }
1178
isOppositeWidthValid() const1179 bool dbTechLayerSpacingEolRule::isOppositeWidthValid() const
1180 {
1181 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1182
1183 return obj->flags_.opposite_width_valid_;
1184 }
1185
setWithinValid(bool within_valid)1186 void dbTechLayerSpacingEolRule::setWithinValid(bool within_valid)
1187 {
1188 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1189
1190 obj->flags_.within_valid_ = within_valid;
1191 }
1192
isWithinValid() const1193 bool dbTechLayerSpacingEolRule::isWithinValid() const
1194 {
1195 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1196
1197 return obj->flags_.within_valid_;
1198 }
1199
setWrongDirWithinValid(bool wrong_dir_within_valid)1200 void dbTechLayerSpacingEolRule::setWrongDirWithinValid(
1201 bool wrong_dir_within_valid)
1202 {
1203 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1204
1205 obj->flags_.wrong_dir_within_valid_ = wrong_dir_within_valid;
1206 }
1207
isWrongDirWithinValid() const1208 bool dbTechLayerSpacingEolRule::isWrongDirWithinValid() const
1209 {
1210 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1211
1212 return obj->flags_.wrong_dir_within_valid_;
1213 }
1214
setSameMaskValid(bool same_mask_valid)1215 void dbTechLayerSpacingEolRule::setSameMaskValid(bool same_mask_valid)
1216 {
1217 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1218
1219 obj->flags_.same_mask_valid_ = same_mask_valid;
1220 }
1221
isSameMaskValid() const1222 bool dbTechLayerSpacingEolRule::isSameMaskValid() const
1223 {
1224 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1225
1226 return obj->flags_.same_mask_valid_;
1227 }
1228
setExceptExactWidthValid(bool except_exact_width_valid)1229 void dbTechLayerSpacingEolRule::setExceptExactWidthValid(
1230 bool except_exact_width_valid)
1231 {
1232 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1233
1234 obj->flags_.except_exact_width_valid_ = except_exact_width_valid;
1235 }
1236
isExceptExactWidthValid() const1237 bool dbTechLayerSpacingEolRule::isExceptExactWidthValid() const
1238 {
1239 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1240
1241 return obj->flags_.except_exact_width_valid_;
1242 }
1243
setFillConcaveCornerValid(bool fill_concave_corner_valid)1244 void dbTechLayerSpacingEolRule::setFillConcaveCornerValid(
1245 bool fill_concave_corner_valid)
1246 {
1247 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1248
1249 obj->flags_.fill_concave_corner_valid_ = fill_concave_corner_valid;
1250 }
1251
isFillConcaveCornerValid() const1252 bool dbTechLayerSpacingEolRule::isFillConcaveCornerValid() const
1253 {
1254 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1255
1256 return obj->flags_.fill_concave_corner_valid_;
1257 }
1258
setWithcutValid(bool withcut_valid)1259 void dbTechLayerSpacingEolRule::setWithcutValid(bool withcut_valid)
1260 {
1261 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1262
1263 obj->flags_.withcut_valid_ = withcut_valid;
1264 }
1265
isWithcutValid() const1266 bool dbTechLayerSpacingEolRule::isWithcutValid() const
1267 {
1268 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1269
1270 return obj->flags_.withcut_valid_;
1271 }
1272
setCutClassValid(bool cut_class_valid)1273 void dbTechLayerSpacingEolRule::setCutClassValid(bool cut_class_valid)
1274 {
1275 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1276
1277 obj->flags_.cut_class_valid_ = cut_class_valid;
1278 }
1279
isCutClassValid() const1280 bool dbTechLayerSpacingEolRule::isCutClassValid() const
1281 {
1282 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1283
1284 return obj->flags_.cut_class_valid_;
1285 }
1286
setWithCutAboveValid(bool with_cut_above_valid)1287 void dbTechLayerSpacingEolRule::setWithCutAboveValid(bool with_cut_above_valid)
1288 {
1289 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1290
1291 obj->flags_.with_cut_above_valid_ = with_cut_above_valid;
1292 }
1293
isWithCutAboveValid() const1294 bool dbTechLayerSpacingEolRule::isWithCutAboveValid() const
1295 {
1296 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1297
1298 return obj->flags_.with_cut_above_valid_;
1299 }
1300
setEnclosureEndValid(bool enclosure_end_valid)1301 void dbTechLayerSpacingEolRule::setEnclosureEndValid(bool enclosure_end_valid)
1302 {
1303 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1304
1305 obj->flags_.enclosure_end_valid_ = enclosure_end_valid;
1306 }
1307
isEnclosureEndValid() const1308 bool dbTechLayerSpacingEolRule::isEnclosureEndValid() const
1309 {
1310 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1311
1312 return obj->flags_.enclosure_end_valid_;
1313 }
1314
setEnclosureEndWithinValid(bool enclosure_end_within_valid)1315 void dbTechLayerSpacingEolRule::setEnclosureEndWithinValid(
1316 bool enclosure_end_within_valid)
1317 {
1318 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1319
1320 obj->flags_.enclosure_end_within_valid_ = enclosure_end_within_valid;
1321 }
1322
isEnclosureEndWithinValid() const1323 bool dbTechLayerSpacingEolRule::isEnclosureEndWithinValid() const
1324 {
1325 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1326
1327 return obj->flags_.enclosure_end_within_valid_;
1328 }
1329
setEndPrlSpacingValid(bool end_prl_spacing_valid)1330 void dbTechLayerSpacingEolRule::setEndPrlSpacingValid(
1331 bool end_prl_spacing_valid)
1332 {
1333 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1334
1335 obj->flags_.end_prl_spacing_valid_ = end_prl_spacing_valid;
1336 }
1337
isEndPrlSpacingValid() const1338 bool dbTechLayerSpacingEolRule::isEndPrlSpacingValid() const
1339 {
1340 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1341
1342 return obj->flags_.end_prl_spacing_valid_;
1343 }
1344
setPrlValid(bool prl_valid)1345 void dbTechLayerSpacingEolRule::setPrlValid(bool prl_valid)
1346 {
1347 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1348
1349 obj->flags_.prl_valid_ = prl_valid;
1350 }
1351
isPrlValid() const1352 bool dbTechLayerSpacingEolRule::isPrlValid() const
1353 {
1354 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1355
1356 return obj->flags_.prl_valid_;
1357 }
1358
setEndToEndValid(bool end_to_end_valid)1359 void dbTechLayerSpacingEolRule::setEndToEndValid(bool end_to_end_valid)
1360 {
1361 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1362
1363 obj->flags_.end_to_end_valid_ = end_to_end_valid;
1364 }
1365
isEndToEndValid() const1366 bool dbTechLayerSpacingEolRule::isEndToEndValid() const
1367 {
1368 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1369
1370 return obj->flags_.end_to_end_valid_;
1371 }
1372
setCutSpacesValid(bool cut_spaces_valid)1373 void dbTechLayerSpacingEolRule::setCutSpacesValid(bool cut_spaces_valid)
1374 {
1375 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1376
1377 obj->flags_.cut_spaces_valid_ = cut_spaces_valid;
1378 }
1379
isCutSpacesValid() const1380 bool dbTechLayerSpacingEolRule::isCutSpacesValid() const
1381 {
1382 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1383
1384 return obj->flags_.cut_spaces_valid_;
1385 }
1386
setExtensionValid(bool extension_valid)1387 void dbTechLayerSpacingEolRule::setExtensionValid(bool extension_valid)
1388 {
1389 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1390
1391 obj->flags_.extension_valid_ = extension_valid;
1392 }
1393
isExtensionValid() const1394 bool dbTechLayerSpacingEolRule::isExtensionValid() const
1395 {
1396 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1397
1398 return obj->flags_.extension_valid_;
1399 }
1400
setWrongDirExtensionValid(bool wrong_dir_extension_valid)1401 void dbTechLayerSpacingEolRule::setWrongDirExtensionValid(
1402 bool wrong_dir_extension_valid)
1403 {
1404 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1405
1406 obj->flags_.wrong_dir_extension_valid_ = wrong_dir_extension_valid;
1407 }
1408
isWrongDirExtensionValid() const1409 bool dbTechLayerSpacingEolRule::isWrongDirExtensionValid() const
1410 {
1411 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1412
1413 return obj->flags_.wrong_dir_extension_valid_;
1414 }
1415
setOtherEndWidthValid(bool other_end_width_valid)1416 void dbTechLayerSpacingEolRule::setOtherEndWidthValid(
1417 bool other_end_width_valid)
1418 {
1419 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1420
1421 obj->flags_.other_end_width_valid_ = other_end_width_valid;
1422 }
1423
isOtherEndWidthValid() const1424 bool dbTechLayerSpacingEolRule::isOtherEndWidthValid() const
1425 {
1426 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1427
1428 return obj->flags_.other_end_width_valid_;
1429 }
1430
setMaxLengthValid(bool max_length_valid)1431 void dbTechLayerSpacingEolRule::setMaxLengthValid(bool max_length_valid)
1432 {
1433 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1434
1435 obj->flags_.max_length_valid_ = max_length_valid;
1436 }
1437
isMaxLengthValid() const1438 bool dbTechLayerSpacingEolRule::isMaxLengthValid() const
1439 {
1440 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1441
1442 return obj->flags_.max_length_valid_;
1443 }
1444
setMinLengthValid(bool min_length_valid)1445 void dbTechLayerSpacingEolRule::setMinLengthValid(bool min_length_valid)
1446 {
1447 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1448
1449 obj->flags_.min_length_valid_ = min_length_valid;
1450 }
1451
isMinLengthValid() const1452 bool dbTechLayerSpacingEolRule::isMinLengthValid() const
1453 {
1454 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1455
1456 return obj->flags_.min_length_valid_;
1457 }
1458
setTwoSidesValid(bool two_sides_valid)1459 void dbTechLayerSpacingEolRule::setTwoSidesValid(bool two_sides_valid)
1460 {
1461 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1462
1463 obj->flags_.two_sides_valid_ = two_sides_valid;
1464 }
1465
isTwoSidesValid() const1466 bool dbTechLayerSpacingEolRule::isTwoSidesValid() const
1467 {
1468 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1469
1470 return obj->flags_.two_sides_valid_;
1471 }
1472
setEqualRectWidthValid(bool equal_rect_width_valid)1473 void dbTechLayerSpacingEolRule::setEqualRectWidthValid(
1474 bool equal_rect_width_valid)
1475 {
1476 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1477
1478 obj->flags_.equal_rect_width_valid_ = equal_rect_width_valid;
1479 }
1480
isEqualRectWidthValid() const1481 bool dbTechLayerSpacingEolRule::isEqualRectWidthValid() const
1482 {
1483 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1484
1485 return obj->flags_.equal_rect_width_valid_;
1486 }
1487
setParallelEdgeValid(bool parallel_edge_valid)1488 void dbTechLayerSpacingEolRule::setParallelEdgeValid(bool parallel_edge_valid)
1489 {
1490 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1491
1492 obj->flags_.parallel_edge_valid_ = parallel_edge_valid;
1493 }
1494
isParallelEdgeValid() const1495 bool dbTechLayerSpacingEolRule::isParallelEdgeValid() const
1496 {
1497 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1498
1499 return obj->flags_.parallel_edge_valid_;
1500 }
1501
setSubtractEolWidthValid(bool subtract_eol_width_valid)1502 void dbTechLayerSpacingEolRule::setSubtractEolWidthValid(
1503 bool subtract_eol_width_valid)
1504 {
1505 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1506
1507 obj->flags_.subtract_eol_width_valid_ = subtract_eol_width_valid;
1508 }
1509
isSubtractEolWidthValid() const1510 bool dbTechLayerSpacingEolRule::isSubtractEolWidthValid() const
1511 {
1512 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1513
1514 return obj->flags_.subtract_eol_width_valid_;
1515 }
1516
setParPrlValid(bool par_prl_valid)1517 void dbTechLayerSpacingEolRule::setParPrlValid(bool par_prl_valid)
1518 {
1519 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1520
1521 obj->flags_.par_prl_valid_ = par_prl_valid;
1522 }
1523
isParPrlValid() const1524 bool dbTechLayerSpacingEolRule::isParPrlValid() const
1525 {
1526 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1527
1528 return obj->flags_.par_prl_valid_;
1529 }
1530
setParMinLengthValid(bool par_min_length_valid)1531 void dbTechLayerSpacingEolRule::setParMinLengthValid(bool par_min_length_valid)
1532 {
1533 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1534
1535 obj->flags_.par_min_length_valid_ = par_min_length_valid;
1536 }
1537
isParMinLengthValid() const1538 bool dbTechLayerSpacingEolRule::isParMinLengthValid() const
1539 {
1540 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1541
1542 return obj->flags_.par_min_length_valid_;
1543 }
1544
setTwoEdgesValid(bool two_edges_valid)1545 void dbTechLayerSpacingEolRule::setTwoEdgesValid(bool two_edges_valid)
1546 {
1547 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1548
1549 obj->flags_.two_edges_valid_ = two_edges_valid;
1550 }
1551
isTwoEdgesValid() const1552 bool dbTechLayerSpacingEolRule::isTwoEdgesValid() const
1553 {
1554 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1555
1556 return obj->flags_.two_edges_valid_;
1557 }
1558
setSameMetalValid(bool same_metal_valid)1559 void dbTechLayerSpacingEolRule::setSameMetalValid(bool same_metal_valid)
1560 {
1561 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1562
1563 obj->flags_.same_metal_valid_ = same_metal_valid;
1564 }
1565
isSameMetalValid() const1566 bool dbTechLayerSpacingEolRule::isSameMetalValid() const
1567 {
1568 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1569
1570 return obj->flags_.same_metal_valid_;
1571 }
1572
setNonEolCornerOnlyValid(bool non_eol_corner_only_valid)1573 void dbTechLayerSpacingEolRule::setNonEolCornerOnlyValid(
1574 bool non_eol_corner_only_valid)
1575 {
1576 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1577
1578 obj->flags_.non_eol_corner_only_valid_ = non_eol_corner_only_valid;
1579 }
1580
isNonEolCornerOnlyValid() const1581 bool dbTechLayerSpacingEolRule::isNonEolCornerOnlyValid() const
1582 {
1583 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1584
1585 return obj->flags_.non_eol_corner_only_valid_;
1586 }
1587
setParallelSameMaskValid(bool parallel_same_mask_valid)1588 void dbTechLayerSpacingEolRule::setParallelSameMaskValid(
1589 bool parallel_same_mask_valid)
1590 {
1591 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1592
1593 obj->flags_.parallel_same_mask_valid_ = parallel_same_mask_valid;
1594 }
1595
isParallelSameMaskValid() const1596 bool dbTechLayerSpacingEolRule::isParallelSameMaskValid() const
1597 {
1598 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1599
1600 return obj->flags_.parallel_same_mask_valid_;
1601 }
1602
setEncloseCutValid(bool enclose_cut_valid)1603 void dbTechLayerSpacingEolRule::setEncloseCutValid(bool enclose_cut_valid)
1604 {
1605 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1606
1607 obj->flags_.enclose_cut_valid_ = enclose_cut_valid;
1608 }
1609
isEncloseCutValid() const1610 bool dbTechLayerSpacingEolRule::isEncloseCutValid() const
1611 {
1612 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1613
1614 return obj->flags_.enclose_cut_valid_;
1615 }
1616
setBelowValid(bool below_valid)1617 void dbTechLayerSpacingEolRule::setBelowValid(bool below_valid)
1618 {
1619 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1620
1621 obj->flags_.below_valid_ = below_valid;
1622 }
1623
isBelowValid() const1624 bool dbTechLayerSpacingEolRule::isBelowValid() const
1625 {
1626 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1627
1628 return obj->flags_.below_valid_;
1629 }
1630
setAboveValid(bool above_valid)1631 void dbTechLayerSpacingEolRule::setAboveValid(bool above_valid)
1632 {
1633 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1634
1635 obj->flags_.above_valid_ = above_valid;
1636 }
1637
isAboveValid() const1638 bool dbTechLayerSpacingEolRule::isAboveValid() const
1639 {
1640 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1641
1642 return obj->flags_.above_valid_;
1643 }
1644
setCutSpacingValid(bool cut_spacing_valid)1645 void dbTechLayerSpacingEolRule::setCutSpacingValid(bool cut_spacing_valid)
1646 {
1647 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1648
1649 obj->flags_.cut_spacing_valid_ = cut_spacing_valid;
1650 }
1651
isCutSpacingValid() const1652 bool dbTechLayerSpacingEolRule::isCutSpacingValid() const
1653 {
1654 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1655
1656 return obj->flags_.cut_spacing_valid_;
1657 }
1658
setAllCutsValid(bool all_cuts_valid)1659 void dbTechLayerSpacingEolRule::setAllCutsValid(bool all_cuts_valid)
1660 {
1661 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1662
1663 obj->flags_.all_cuts_valid_ = all_cuts_valid;
1664 }
1665
isAllCutsValid() const1666 bool dbTechLayerSpacingEolRule::isAllCutsValid() const
1667 {
1668 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1669
1670 return obj->flags_.all_cuts_valid_;
1671 }
1672
setToConcaveCornerValid(bool to_concave_corner_valid)1673 void dbTechLayerSpacingEolRule::setToConcaveCornerValid(
1674 bool to_concave_corner_valid)
1675 {
1676 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1677
1678 obj->flags_.to_concave_corner_valid_ = to_concave_corner_valid;
1679 }
1680
isToConcaveCornerValid() const1681 bool dbTechLayerSpacingEolRule::isToConcaveCornerValid() const
1682 {
1683 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1684
1685 return obj->flags_.to_concave_corner_valid_;
1686 }
1687
setMinAdjacentLengthValid(bool min_adjacent_length_valid)1688 void dbTechLayerSpacingEolRule::setMinAdjacentLengthValid(
1689 bool min_adjacent_length_valid)
1690 {
1691 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1692
1693 obj->flags_.min_adjacent_length_valid_ = min_adjacent_length_valid;
1694 }
1695
isMinAdjacentLengthValid() const1696 bool dbTechLayerSpacingEolRule::isMinAdjacentLengthValid() const
1697 {
1698 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1699
1700 return obj->flags_.min_adjacent_length_valid_;
1701 }
1702
setTwoMinAdjLengthValid(bool two_min_adj_length_valid)1703 void dbTechLayerSpacingEolRule::setTwoMinAdjLengthValid(
1704 bool two_min_adj_length_valid)
1705 {
1706 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1707
1708 obj->flags_.two_min_adj_length_valid_ = two_min_adj_length_valid;
1709 }
1710
isTwoMinAdjLengthValid() const1711 bool dbTechLayerSpacingEolRule::isTwoMinAdjLengthValid() const
1712 {
1713 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1714
1715 return obj->flags_.two_min_adj_length_valid_;
1716 }
1717
setToNotchLengthValid(bool to_notch_length_valid)1718 void dbTechLayerSpacingEolRule::setToNotchLengthValid(
1719 bool to_notch_length_valid)
1720 {
1721 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1722
1723 obj->flags_.to_notch_length_valid_ = to_notch_length_valid;
1724 }
1725
isToNotchLengthValid() const1726 bool dbTechLayerSpacingEolRule::isToNotchLengthValid() const
1727 {
1728 _dbTechLayerSpacingEolRule* obj = (_dbTechLayerSpacingEolRule*) this;
1729
1730 return obj->flags_.to_notch_length_valid_;
1731 }
1732
1733 // User Code Begin dbTechLayerSpacingEolRulePublicMethods
create(dbTechLayer * _layer)1734 dbTechLayerSpacingEolRule* dbTechLayerSpacingEolRule::create(
1735 dbTechLayer* _layer)
1736 {
1737 _dbTechLayer* layer = (_dbTechLayer*) _layer;
1738 _dbTechLayerSpacingEolRule* newrule = layer->spacing_eol_rules_tbl_->create();
1739 newrule->_layer = _layer->getImpl()->getOID();
1740
1741 return ((dbTechLayerSpacingEolRule*) newrule);
1742 }
1743
1744 dbTechLayerSpacingEolRule*
getTechLayerSpacingEolRule(dbTechLayer * inly,uint dbid)1745 dbTechLayerSpacingEolRule::getTechLayerSpacingEolRule(dbTechLayer* inly,
1746 uint dbid)
1747 {
1748 _dbTechLayer* layer = (_dbTechLayer*) inly;
1749 return (dbTechLayerSpacingEolRule*) layer->spacing_eol_rules_tbl_->getPtr(
1750 dbid);
1751 }
1752
destroy(dbTechLayerSpacingEolRule * rule)1753 void dbTechLayerSpacingEolRule::destroy(dbTechLayerSpacingEolRule* rule)
1754 {
1755 _dbTechLayer* layer = (_dbTechLayer*) rule->getImpl()->getOwner();
1756 dbProperty::destroyProperties(rule);
1757 layer->spacing_eol_rules_tbl_->destroy((_dbTechLayerSpacingEolRule*) rule);
1758 }
1759
1760 // User Code End dbTechLayerSpacingEolRulePublicMethods
1761 } // namespace odb
1762 // Generator Code End Cpp
1763