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 "dbTechLayerCutSpacingTableDefRule.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 // User Code Begin Includes
43 #include "dbTech.h"
44 #include "dbTechLayerCutClassRule.h"
45 // User Code End Includes
46 namespace odb {
47
48 template class dbTable<_dbTechLayerCutSpacingTableDefRule>;
49
operator ==(const _dbTechLayerCutSpacingTableDefRule & rhs) const50 bool _dbTechLayerCutSpacingTableDefRule::operator==(
51 const _dbTechLayerCutSpacingTableDefRule& rhs) const
52 {
53 if (flags_.default_valid_ != rhs.flags_.default_valid_)
54 return false;
55
56 if (flags_.same_mask_ != rhs.flags_.same_mask_)
57 return false;
58
59 if (flags_.same_net_ != rhs.flags_.same_net_)
60 return false;
61
62 if (flags_.same_metal_ != rhs.flags_.same_metal_)
63 return false;
64
65 if (flags_.same_via_ != rhs.flags_.same_via_)
66 return false;
67
68 if (flags_.layer_valid_ != rhs.flags_.layer_valid_)
69 return false;
70
71 if (flags_.no_stack_ != rhs.flags_.no_stack_)
72 return false;
73
74 if (flags_.non_zero_enclosure_ != rhs.flags_.non_zero_enclosure_)
75 return false;
76
77 if (flags_.prl_for_aligned_cut_ != rhs.flags_.prl_for_aligned_cut_)
78 return false;
79
80 if (flags_.center_to_center_valid_ != rhs.flags_.center_to_center_valid_)
81 return false;
82
83 if (flags_.center_and_edge_valid_ != rhs.flags_.center_and_edge_valid_)
84 return false;
85
86 if (flags_.no_prl_ != rhs.flags_.no_prl_)
87 return false;
88
89 if (flags_.prl_valid_ != rhs.flags_.prl_valid_)
90 return false;
91
92 if (flags_.max_x_y_ != rhs.flags_.max_x_y_)
93 return false;
94
95 if (flags_.end_extension_valid_ != rhs.flags_.end_extension_valid_)
96 return false;
97
98 if (flags_.side_extension_valid_ != rhs.flags_.side_extension_valid_)
99 return false;
100
101 if (flags_.exact_aligned_spacing_valid_
102 != rhs.flags_.exact_aligned_spacing_valid_)
103 return false;
104
105 if (flags_.horizontal_ != rhs.flags_.horizontal_)
106 return false;
107
108 if (flags_.prl_horizontal_ != rhs.flags_.prl_horizontal_)
109 return false;
110
111 if (flags_.vertical_ != rhs.flags_.vertical_)
112 return false;
113
114 if (flags_.prl_vertical_ != rhs.flags_.prl_vertical_)
115 return false;
116
117 if (flags_.non_opposite_enclosure_spacing_valid_
118 != rhs.flags_.non_opposite_enclosure_spacing_valid_)
119 return false;
120
121 if (flags_.opposite_enclosure_resize_spacing_valid_
122 != rhs.flags_.opposite_enclosure_resize_spacing_valid_)
123 return false;
124
125 if (default_ != rhs.default_)
126 return false;
127
128 if (second_layer_ != rhs.second_layer_)
129 return false;
130
131 if (prl_ != rhs.prl_)
132 return false;
133
134 if (extension_ != rhs.extension_)
135 return false;
136
137 // User Code Begin ==
138 // User Code End ==
139 return true;
140 }
operator <(const _dbTechLayerCutSpacingTableDefRule & rhs) const141 bool _dbTechLayerCutSpacingTableDefRule::operator<(
142 const _dbTechLayerCutSpacingTableDefRule& rhs) const
143 {
144 // User Code Begin <
145 // User Code End <
146 return true;
147 }
differences(dbDiff & diff,const char * field,const _dbTechLayerCutSpacingTableDefRule & rhs) const148 void _dbTechLayerCutSpacingTableDefRule::differences(
149 dbDiff& diff,
150 const char* field,
151 const _dbTechLayerCutSpacingTableDefRule& rhs) const
152 {
153 DIFF_BEGIN
154
155 DIFF_FIELD(flags_.default_valid_);
156 DIFF_FIELD(flags_.same_mask_);
157 DIFF_FIELD(flags_.same_net_);
158 DIFF_FIELD(flags_.same_metal_);
159 DIFF_FIELD(flags_.same_via_);
160 DIFF_FIELD(flags_.layer_valid_);
161 DIFF_FIELD(flags_.no_stack_);
162 DIFF_FIELD(flags_.non_zero_enclosure_);
163 DIFF_FIELD(flags_.prl_for_aligned_cut_);
164 DIFF_FIELD(flags_.center_to_center_valid_);
165 DIFF_FIELD(flags_.center_and_edge_valid_);
166 DIFF_FIELD(flags_.no_prl_);
167 DIFF_FIELD(flags_.prl_valid_);
168 DIFF_FIELD(flags_.max_x_y_);
169 DIFF_FIELD(flags_.end_extension_valid_);
170 DIFF_FIELD(flags_.side_extension_valid_);
171 DIFF_FIELD(flags_.exact_aligned_spacing_valid_);
172 DIFF_FIELD(flags_.horizontal_);
173 DIFF_FIELD(flags_.prl_horizontal_);
174 DIFF_FIELD(flags_.vertical_);
175 DIFF_FIELD(flags_.prl_vertical_);
176 DIFF_FIELD(flags_.non_opposite_enclosure_spacing_valid_);
177 DIFF_FIELD(flags_.opposite_enclosure_resize_spacing_valid_);
178 DIFF_FIELD(default_);
179 DIFF_FIELD(second_layer_);
180 DIFF_FIELD(prl_);
181 DIFF_FIELD(extension_);
182 // User Code Begin Differences
183 // User Code End Differences
184 DIFF_END
185 }
out(dbDiff & diff,char side,const char * field) const186 void _dbTechLayerCutSpacingTableDefRule::out(dbDiff& diff,
187 char side,
188 const char* field) const
189 {
190 DIFF_OUT_BEGIN
191 DIFF_OUT_FIELD(flags_.default_valid_);
192 DIFF_OUT_FIELD(flags_.same_mask_);
193 DIFF_OUT_FIELD(flags_.same_net_);
194 DIFF_OUT_FIELD(flags_.same_metal_);
195 DIFF_OUT_FIELD(flags_.same_via_);
196 DIFF_OUT_FIELD(flags_.layer_valid_);
197 DIFF_OUT_FIELD(flags_.no_stack_);
198 DIFF_OUT_FIELD(flags_.non_zero_enclosure_);
199 DIFF_OUT_FIELD(flags_.prl_for_aligned_cut_);
200 DIFF_OUT_FIELD(flags_.center_to_center_valid_);
201 DIFF_OUT_FIELD(flags_.center_and_edge_valid_);
202 DIFF_OUT_FIELD(flags_.no_prl_);
203 DIFF_OUT_FIELD(flags_.prl_valid_);
204 DIFF_OUT_FIELD(flags_.max_x_y_);
205 DIFF_OUT_FIELD(flags_.end_extension_valid_);
206 DIFF_OUT_FIELD(flags_.side_extension_valid_);
207 DIFF_OUT_FIELD(flags_.exact_aligned_spacing_valid_);
208 DIFF_OUT_FIELD(flags_.horizontal_);
209 DIFF_OUT_FIELD(flags_.prl_horizontal_);
210 DIFF_OUT_FIELD(flags_.vertical_);
211 DIFF_OUT_FIELD(flags_.prl_vertical_);
212 DIFF_OUT_FIELD(flags_.non_opposite_enclosure_spacing_valid_);
213 DIFF_OUT_FIELD(flags_.opposite_enclosure_resize_spacing_valid_);
214 DIFF_OUT_FIELD(default_);
215 DIFF_OUT_FIELD(second_layer_);
216 DIFF_OUT_FIELD(prl_);
217 DIFF_OUT_FIELD(extension_);
218
219 // User Code Begin Out
220 // User Code End Out
221 DIFF_END
222 }
_dbTechLayerCutSpacingTableDefRule(_dbDatabase * db)223 _dbTechLayerCutSpacingTableDefRule::_dbTechLayerCutSpacingTableDefRule(
224 _dbDatabase* db)
225 {
226 uint32_t* flags__bit_field = (uint32_t*) &flags_;
227 *flags__bit_field = 0;
228 default_ = 0;
229 prl_ = 0;
230 extension_ = 0;
231 // User Code Begin Constructor
232 // User Code End Constructor
233 }
_dbTechLayerCutSpacingTableDefRule(_dbDatabase * db,const _dbTechLayerCutSpacingTableDefRule & r)234 _dbTechLayerCutSpacingTableDefRule::_dbTechLayerCutSpacingTableDefRule(
235 _dbDatabase* db,
236 const _dbTechLayerCutSpacingTableDefRule& r)
237 {
238 flags_.default_valid_ = r.flags_.default_valid_;
239 flags_.same_mask_ = r.flags_.same_mask_;
240 flags_.same_net_ = r.flags_.same_net_;
241 flags_.same_metal_ = r.flags_.same_metal_;
242 flags_.same_via_ = r.flags_.same_via_;
243 flags_.layer_valid_ = r.flags_.layer_valid_;
244 flags_.no_stack_ = r.flags_.no_stack_;
245 flags_.non_zero_enclosure_ = r.flags_.non_zero_enclosure_;
246 flags_.prl_for_aligned_cut_ = r.flags_.prl_for_aligned_cut_;
247 flags_.center_to_center_valid_ = r.flags_.center_to_center_valid_;
248 flags_.center_and_edge_valid_ = r.flags_.center_and_edge_valid_;
249 flags_.no_prl_ = r.flags_.no_prl_;
250 flags_.prl_valid_ = r.flags_.prl_valid_;
251 flags_.max_x_y_ = r.flags_.max_x_y_;
252 flags_.end_extension_valid_ = r.flags_.end_extension_valid_;
253 flags_.side_extension_valid_ = r.flags_.side_extension_valid_;
254 flags_.exact_aligned_spacing_valid_ = r.flags_.exact_aligned_spacing_valid_;
255 flags_.horizontal_ = r.flags_.horizontal_;
256 flags_.prl_horizontal_ = r.flags_.prl_horizontal_;
257 flags_.vertical_ = r.flags_.vertical_;
258 flags_.prl_vertical_ = r.flags_.prl_vertical_;
259 flags_.non_opposite_enclosure_spacing_valid_
260 = r.flags_.non_opposite_enclosure_spacing_valid_;
261 flags_.opposite_enclosure_resize_spacing_valid_
262 = r.flags_.opposite_enclosure_resize_spacing_valid_;
263 flags_.spare_bits_ = r.flags_.spare_bits_;
264 default_ = r.default_;
265 second_layer_ = r.second_layer_;
266 prl_ = r.prl_;
267 extension_ = r.extension_;
268 // User Code Begin CopyConstructor
269 // User Code End CopyConstructor
270 }
271
operator >>(dbIStream & stream,_dbTechLayerCutSpacingTableDefRule & obj)272 dbIStream& operator>>(dbIStream& stream,
273 _dbTechLayerCutSpacingTableDefRule& obj)
274 {
275 uint32_t* flags__bit_field = (uint32_t*) &obj.flags_;
276 stream >> *flags__bit_field;
277 stream >> obj.default_;
278 stream >> obj.second_layer_;
279 stream >> obj.prl_for_aligned_cut_tbl_;
280 stream >> obj.center_to_center_tbl_;
281 stream >> obj.center_and_edge_tbl_;
282 stream >> obj.prl_;
283 stream >> obj.prl_tbl_;
284 stream >> obj.extension_;
285 stream >> obj.end_extension_tbl_;
286 stream >> obj.side_extension_tbl_;
287 stream >> obj.exact_aligned_spacing_tbl_;
288 stream >> obj.non_opp_enc_spacing_tbl_;
289 stream >> obj.opp_enc_spacing_tbl_;
290 stream >> obj.spacing_tbl_;
291 stream >> obj.row_map_;
292 stream >> obj.col_map_;
293 // User Code Begin >>
294 // User Code End >>
295 return stream;
296 }
operator <<(dbOStream & stream,const _dbTechLayerCutSpacingTableDefRule & obj)297 dbOStream& operator<<(dbOStream& stream,
298 const _dbTechLayerCutSpacingTableDefRule& obj)
299 {
300 uint32_t* flags__bit_field = (uint32_t*) &obj.flags_;
301 stream << *flags__bit_field;
302 stream << obj.default_;
303 stream << obj.second_layer_;
304 stream << obj.prl_for_aligned_cut_tbl_;
305 stream << obj.center_to_center_tbl_;
306 stream << obj.center_and_edge_tbl_;
307 stream << obj.prl_;
308 stream << obj.prl_tbl_;
309 stream << obj.extension_;
310 stream << obj.end_extension_tbl_;
311 stream << obj.side_extension_tbl_;
312 stream << obj.exact_aligned_spacing_tbl_;
313 stream << obj.non_opp_enc_spacing_tbl_;
314 stream << obj.opp_enc_spacing_tbl_;
315 stream << obj.spacing_tbl_;
316 stream << obj.row_map_;
317 stream << obj.col_map_;
318 // User Code Begin <<
319 // User Code End <<
320 return stream;
321 }
322
~_dbTechLayerCutSpacingTableDefRule()323 _dbTechLayerCutSpacingTableDefRule::~_dbTechLayerCutSpacingTableDefRule()
324 {
325 // User Code Begin Destructor
326 // User Code End Destructor
327 }
328
329 // User Code Begin PrivateMethods
330 // User Code End PrivateMethods
331
332 ////////////////////////////////////////////////////////////////////
333 //
334 // dbTechLayerCutSpacingTableDefRule - Methods
335 //
336 ////////////////////////////////////////////////////////////////////
337
setDefault(int spacing)338 void dbTechLayerCutSpacingTableDefRule::setDefault(int spacing)
339 {
340 _dbTechLayerCutSpacingTableDefRule* obj
341 = (_dbTechLayerCutSpacingTableDefRule*) this;
342
343 obj->default_ = spacing;
344 }
345
getDefault() const346 int dbTechLayerCutSpacingTableDefRule::getDefault() const
347 {
348 _dbTechLayerCutSpacingTableDefRule* obj
349 = (_dbTechLayerCutSpacingTableDefRule*) this;
350 return obj->default_;
351 }
352
setSecondLayer(dbTechLayer * second_layer)353 void dbTechLayerCutSpacingTableDefRule::setSecondLayer(
354 dbTechLayer* second_layer)
355 {
356 _dbTechLayerCutSpacingTableDefRule* obj
357 = (_dbTechLayerCutSpacingTableDefRule*) this;
358
359 obj->second_layer_ = second_layer->getImpl()->getOID();
360 }
361
setPrl(int prl)362 void dbTechLayerCutSpacingTableDefRule::setPrl(int prl)
363 {
364 _dbTechLayerCutSpacingTableDefRule* obj
365 = (_dbTechLayerCutSpacingTableDefRule*) this;
366
367 obj->prl_ = prl;
368 }
369
getPrl() const370 int dbTechLayerCutSpacingTableDefRule::getPrl() const
371 {
372 _dbTechLayerCutSpacingTableDefRule* obj
373 = (_dbTechLayerCutSpacingTableDefRule*) this;
374 return obj->prl_;
375 }
376
setExtension(int extension)377 void dbTechLayerCutSpacingTableDefRule::setExtension(int extension)
378 {
379 _dbTechLayerCutSpacingTableDefRule* obj
380 = (_dbTechLayerCutSpacingTableDefRule*) this;
381
382 obj->extension_ = extension;
383 }
384
getExtension() const385 int dbTechLayerCutSpacingTableDefRule::getExtension() const
386 {
387 _dbTechLayerCutSpacingTableDefRule* obj
388 = (_dbTechLayerCutSpacingTableDefRule*) this;
389 return obj->extension_;
390 }
391
setDefaultValid(bool default_valid)392 void dbTechLayerCutSpacingTableDefRule::setDefaultValid(bool default_valid)
393 {
394 _dbTechLayerCutSpacingTableDefRule* obj
395 = (_dbTechLayerCutSpacingTableDefRule*) this;
396
397 obj->flags_.default_valid_ = default_valid;
398 }
399
isDefaultValid() const400 bool dbTechLayerCutSpacingTableDefRule::isDefaultValid() const
401 {
402 _dbTechLayerCutSpacingTableDefRule* obj
403 = (_dbTechLayerCutSpacingTableDefRule*) this;
404
405 return obj->flags_.default_valid_;
406 }
407
setSameMask(bool same_mask)408 void dbTechLayerCutSpacingTableDefRule::setSameMask(bool same_mask)
409 {
410 _dbTechLayerCutSpacingTableDefRule* obj
411 = (_dbTechLayerCutSpacingTableDefRule*) this;
412
413 obj->flags_.same_mask_ = same_mask;
414 }
415
isSameMask() const416 bool dbTechLayerCutSpacingTableDefRule::isSameMask() const
417 {
418 _dbTechLayerCutSpacingTableDefRule* obj
419 = (_dbTechLayerCutSpacingTableDefRule*) this;
420
421 return obj->flags_.same_mask_;
422 }
423
setSameNet(bool same_net)424 void dbTechLayerCutSpacingTableDefRule::setSameNet(bool same_net)
425 {
426 _dbTechLayerCutSpacingTableDefRule* obj
427 = (_dbTechLayerCutSpacingTableDefRule*) this;
428
429 obj->flags_.same_net_ = same_net;
430 }
431
isSameNet() const432 bool dbTechLayerCutSpacingTableDefRule::isSameNet() const
433 {
434 _dbTechLayerCutSpacingTableDefRule* obj
435 = (_dbTechLayerCutSpacingTableDefRule*) this;
436
437 return obj->flags_.same_net_;
438 }
439
setSameMetal(bool same_metal)440 void dbTechLayerCutSpacingTableDefRule::setSameMetal(bool same_metal)
441 {
442 _dbTechLayerCutSpacingTableDefRule* obj
443 = (_dbTechLayerCutSpacingTableDefRule*) this;
444
445 obj->flags_.same_metal_ = same_metal;
446 }
447
isSameMetal() const448 bool dbTechLayerCutSpacingTableDefRule::isSameMetal() const
449 {
450 _dbTechLayerCutSpacingTableDefRule* obj
451 = (_dbTechLayerCutSpacingTableDefRule*) this;
452
453 return obj->flags_.same_metal_;
454 }
455
setSameVia(bool same_via)456 void dbTechLayerCutSpacingTableDefRule::setSameVia(bool same_via)
457 {
458 _dbTechLayerCutSpacingTableDefRule* obj
459 = (_dbTechLayerCutSpacingTableDefRule*) this;
460
461 obj->flags_.same_via_ = same_via;
462 }
463
isSameVia() const464 bool dbTechLayerCutSpacingTableDefRule::isSameVia() const
465 {
466 _dbTechLayerCutSpacingTableDefRule* obj
467 = (_dbTechLayerCutSpacingTableDefRule*) this;
468
469 return obj->flags_.same_via_;
470 }
471
setLayerValid(bool layer_valid)472 void dbTechLayerCutSpacingTableDefRule::setLayerValid(bool layer_valid)
473 {
474 _dbTechLayerCutSpacingTableDefRule* obj
475 = (_dbTechLayerCutSpacingTableDefRule*) this;
476
477 obj->flags_.layer_valid_ = layer_valid;
478 }
479
isLayerValid() const480 bool dbTechLayerCutSpacingTableDefRule::isLayerValid() const
481 {
482 _dbTechLayerCutSpacingTableDefRule* obj
483 = (_dbTechLayerCutSpacingTableDefRule*) this;
484
485 return obj->flags_.layer_valid_;
486 }
487
setNoStack(bool no_stack)488 void dbTechLayerCutSpacingTableDefRule::setNoStack(bool no_stack)
489 {
490 _dbTechLayerCutSpacingTableDefRule* obj
491 = (_dbTechLayerCutSpacingTableDefRule*) this;
492
493 obj->flags_.no_stack_ = no_stack;
494 }
495
isNoStack() const496 bool dbTechLayerCutSpacingTableDefRule::isNoStack() const
497 {
498 _dbTechLayerCutSpacingTableDefRule* obj
499 = (_dbTechLayerCutSpacingTableDefRule*) this;
500
501 return obj->flags_.no_stack_;
502 }
503
setNonZeroEnclosure(bool non_zero_enclosure)504 void dbTechLayerCutSpacingTableDefRule::setNonZeroEnclosure(
505 bool non_zero_enclosure)
506 {
507 _dbTechLayerCutSpacingTableDefRule* obj
508 = (_dbTechLayerCutSpacingTableDefRule*) this;
509
510 obj->flags_.non_zero_enclosure_ = non_zero_enclosure;
511 }
512
isNonZeroEnclosure() const513 bool dbTechLayerCutSpacingTableDefRule::isNonZeroEnclosure() const
514 {
515 _dbTechLayerCutSpacingTableDefRule* obj
516 = (_dbTechLayerCutSpacingTableDefRule*) this;
517
518 return obj->flags_.non_zero_enclosure_;
519 }
520
setPrlForAlignedCut(bool prl_for_aligned_cut)521 void dbTechLayerCutSpacingTableDefRule::setPrlForAlignedCut(
522 bool prl_for_aligned_cut)
523 {
524 _dbTechLayerCutSpacingTableDefRule* obj
525 = (_dbTechLayerCutSpacingTableDefRule*) this;
526
527 obj->flags_.prl_for_aligned_cut_ = prl_for_aligned_cut;
528 }
529
isPrlForAlignedCut() const530 bool dbTechLayerCutSpacingTableDefRule::isPrlForAlignedCut() const
531 {
532 _dbTechLayerCutSpacingTableDefRule* obj
533 = (_dbTechLayerCutSpacingTableDefRule*) this;
534
535 return obj->flags_.prl_for_aligned_cut_;
536 }
537
setCenterToCenterValid(bool center_to_center_valid)538 void dbTechLayerCutSpacingTableDefRule::setCenterToCenterValid(
539 bool center_to_center_valid)
540 {
541 _dbTechLayerCutSpacingTableDefRule* obj
542 = (_dbTechLayerCutSpacingTableDefRule*) this;
543
544 obj->flags_.center_to_center_valid_ = center_to_center_valid;
545 }
546
isCenterToCenterValid() const547 bool dbTechLayerCutSpacingTableDefRule::isCenterToCenterValid() const
548 {
549 _dbTechLayerCutSpacingTableDefRule* obj
550 = (_dbTechLayerCutSpacingTableDefRule*) this;
551
552 return obj->flags_.center_to_center_valid_;
553 }
554
setCenterAndEdgeValid(bool center_and_edge_valid)555 void dbTechLayerCutSpacingTableDefRule::setCenterAndEdgeValid(
556 bool center_and_edge_valid)
557 {
558 _dbTechLayerCutSpacingTableDefRule* obj
559 = (_dbTechLayerCutSpacingTableDefRule*) this;
560
561 obj->flags_.center_and_edge_valid_ = center_and_edge_valid;
562 }
563
isCenterAndEdgeValid() const564 bool dbTechLayerCutSpacingTableDefRule::isCenterAndEdgeValid() const
565 {
566 _dbTechLayerCutSpacingTableDefRule* obj
567 = (_dbTechLayerCutSpacingTableDefRule*) this;
568
569 return obj->flags_.center_and_edge_valid_;
570 }
571
setNoPrl(bool no_prl)572 void dbTechLayerCutSpacingTableDefRule::setNoPrl(bool no_prl)
573 {
574 _dbTechLayerCutSpacingTableDefRule* obj
575 = (_dbTechLayerCutSpacingTableDefRule*) this;
576
577 obj->flags_.no_prl_ = no_prl;
578 }
579
isNoPrl() const580 bool dbTechLayerCutSpacingTableDefRule::isNoPrl() const
581 {
582 _dbTechLayerCutSpacingTableDefRule* obj
583 = (_dbTechLayerCutSpacingTableDefRule*) this;
584
585 return obj->flags_.no_prl_;
586 }
587
setPrlValid(bool prl_valid)588 void dbTechLayerCutSpacingTableDefRule::setPrlValid(bool prl_valid)
589 {
590 _dbTechLayerCutSpacingTableDefRule* obj
591 = (_dbTechLayerCutSpacingTableDefRule*) this;
592
593 obj->flags_.prl_valid_ = prl_valid;
594 }
595
isPrlValid() const596 bool dbTechLayerCutSpacingTableDefRule::isPrlValid() const
597 {
598 _dbTechLayerCutSpacingTableDefRule* obj
599 = (_dbTechLayerCutSpacingTableDefRule*) this;
600
601 return obj->flags_.prl_valid_;
602 }
603
setMaxXY(bool max_x_y)604 void dbTechLayerCutSpacingTableDefRule::setMaxXY(bool max_x_y)
605 {
606 _dbTechLayerCutSpacingTableDefRule* obj
607 = (_dbTechLayerCutSpacingTableDefRule*) this;
608
609 obj->flags_.max_x_y_ = max_x_y;
610 }
611
isMaxXY() const612 bool dbTechLayerCutSpacingTableDefRule::isMaxXY() const
613 {
614 _dbTechLayerCutSpacingTableDefRule* obj
615 = (_dbTechLayerCutSpacingTableDefRule*) this;
616
617 return obj->flags_.max_x_y_;
618 }
619
setEndExtensionValid(bool end_extension_valid)620 void dbTechLayerCutSpacingTableDefRule::setEndExtensionValid(
621 bool end_extension_valid)
622 {
623 _dbTechLayerCutSpacingTableDefRule* obj
624 = (_dbTechLayerCutSpacingTableDefRule*) this;
625
626 obj->flags_.end_extension_valid_ = end_extension_valid;
627 }
628
isEndExtensionValid() const629 bool dbTechLayerCutSpacingTableDefRule::isEndExtensionValid() const
630 {
631 _dbTechLayerCutSpacingTableDefRule* obj
632 = (_dbTechLayerCutSpacingTableDefRule*) this;
633
634 return obj->flags_.end_extension_valid_;
635 }
636
setSideExtensionValid(bool side_extension_valid)637 void dbTechLayerCutSpacingTableDefRule::setSideExtensionValid(
638 bool side_extension_valid)
639 {
640 _dbTechLayerCutSpacingTableDefRule* obj
641 = (_dbTechLayerCutSpacingTableDefRule*) this;
642
643 obj->flags_.side_extension_valid_ = side_extension_valid;
644 }
645
isSideExtensionValid() const646 bool dbTechLayerCutSpacingTableDefRule::isSideExtensionValid() const
647 {
648 _dbTechLayerCutSpacingTableDefRule* obj
649 = (_dbTechLayerCutSpacingTableDefRule*) this;
650
651 return obj->flags_.side_extension_valid_;
652 }
653
setExactAlignedSpacingValid(bool exact_aligned_spacing_valid)654 void dbTechLayerCutSpacingTableDefRule::setExactAlignedSpacingValid(
655 bool exact_aligned_spacing_valid)
656 {
657 _dbTechLayerCutSpacingTableDefRule* obj
658 = (_dbTechLayerCutSpacingTableDefRule*) this;
659
660 obj->flags_.exact_aligned_spacing_valid_ = exact_aligned_spacing_valid;
661 }
662
isExactAlignedSpacingValid() const663 bool dbTechLayerCutSpacingTableDefRule::isExactAlignedSpacingValid() const
664 {
665 _dbTechLayerCutSpacingTableDefRule* obj
666 = (_dbTechLayerCutSpacingTableDefRule*) this;
667
668 return obj->flags_.exact_aligned_spacing_valid_;
669 }
670
setHorizontal(bool horizontal)671 void dbTechLayerCutSpacingTableDefRule::setHorizontal(bool horizontal)
672 {
673 _dbTechLayerCutSpacingTableDefRule* obj
674 = (_dbTechLayerCutSpacingTableDefRule*) this;
675
676 obj->flags_.horizontal_ = horizontal;
677 }
678
isHorizontal() const679 bool dbTechLayerCutSpacingTableDefRule::isHorizontal() const
680 {
681 _dbTechLayerCutSpacingTableDefRule* obj
682 = (_dbTechLayerCutSpacingTableDefRule*) this;
683
684 return obj->flags_.horizontal_;
685 }
686
setPrlHorizontal(bool prl_horizontal)687 void dbTechLayerCutSpacingTableDefRule::setPrlHorizontal(bool prl_horizontal)
688 {
689 _dbTechLayerCutSpacingTableDefRule* obj
690 = (_dbTechLayerCutSpacingTableDefRule*) this;
691
692 obj->flags_.prl_horizontal_ = prl_horizontal;
693 }
694
isPrlHorizontal() const695 bool dbTechLayerCutSpacingTableDefRule::isPrlHorizontal() const
696 {
697 _dbTechLayerCutSpacingTableDefRule* obj
698 = (_dbTechLayerCutSpacingTableDefRule*) this;
699
700 return obj->flags_.prl_horizontal_;
701 }
702
setVertical(bool vertical)703 void dbTechLayerCutSpacingTableDefRule::setVertical(bool vertical)
704 {
705 _dbTechLayerCutSpacingTableDefRule* obj
706 = (_dbTechLayerCutSpacingTableDefRule*) this;
707
708 obj->flags_.vertical_ = vertical;
709 }
710
isVertical() const711 bool dbTechLayerCutSpacingTableDefRule::isVertical() const
712 {
713 _dbTechLayerCutSpacingTableDefRule* obj
714 = (_dbTechLayerCutSpacingTableDefRule*) this;
715
716 return obj->flags_.vertical_;
717 }
718
setPrlVertical(bool prl_vertical)719 void dbTechLayerCutSpacingTableDefRule::setPrlVertical(bool prl_vertical)
720 {
721 _dbTechLayerCutSpacingTableDefRule* obj
722 = (_dbTechLayerCutSpacingTableDefRule*) this;
723
724 obj->flags_.prl_vertical_ = prl_vertical;
725 }
726
isPrlVertical() const727 bool dbTechLayerCutSpacingTableDefRule::isPrlVertical() const
728 {
729 _dbTechLayerCutSpacingTableDefRule* obj
730 = (_dbTechLayerCutSpacingTableDefRule*) this;
731
732 return obj->flags_.prl_vertical_;
733 }
734
setNonOppositeEnclosureSpacingValid(bool non_opposite_enclosure_spacing_valid)735 void dbTechLayerCutSpacingTableDefRule::setNonOppositeEnclosureSpacingValid(
736 bool non_opposite_enclosure_spacing_valid)
737 {
738 _dbTechLayerCutSpacingTableDefRule* obj
739 = (_dbTechLayerCutSpacingTableDefRule*) this;
740
741 obj->flags_.non_opposite_enclosure_spacing_valid_
742 = non_opposite_enclosure_spacing_valid;
743 }
744
isNonOppositeEnclosureSpacingValid() const745 bool dbTechLayerCutSpacingTableDefRule::isNonOppositeEnclosureSpacingValid()
746 const
747 {
748 _dbTechLayerCutSpacingTableDefRule* obj
749 = (_dbTechLayerCutSpacingTableDefRule*) this;
750
751 return obj->flags_.non_opposite_enclosure_spacing_valid_;
752 }
753
setOppositeEnclosureResizeSpacingValid(bool opposite_enclosure_resize_spacing_valid)754 void dbTechLayerCutSpacingTableDefRule::setOppositeEnclosureResizeSpacingValid(
755 bool opposite_enclosure_resize_spacing_valid)
756 {
757 _dbTechLayerCutSpacingTableDefRule* obj
758 = (_dbTechLayerCutSpacingTableDefRule*) this;
759
760 obj->flags_.opposite_enclosure_resize_spacing_valid_
761 = opposite_enclosure_resize_spacing_valid;
762 }
763
isOppositeEnclosureResizeSpacingValid() const764 bool dbTechLayerCutSpacingTableDefRule::isOppositeEnclosureResizeSpacingValid()
765 const
766 {
767 _dbTechLayerCutSpacingTableDefRule* obj
768 = (_dbTechLayerCutSpacingTableDefRule*) this;
769
770 return obj->flags_.opposite_enclosure_resize_spacing_valid_;
771 }
772
773 // User Code Begin dbTechLayerCutSpacingTableDefRulePublicMethods
addPrlForAlignedCutEntry(dbTechLayerCutClassRule * from,dbTechLayerCutClassRule * to)774 void dbTechLayerCutSpacingTableDefRule::addPrlForAlignedCutEntry(
775 dbTechLayerCutClassRule* from,
776 dbTechLayerCutClassRule* to)
777 {
778 if (from == nullptr || to == nullptr)
779 return;
780 _dbTechLayerCutSpacingTableDefRule* obj
781 = (_dbTechLayerCutSpacingTableDefRule*) this;
782 obj->prl_for_aligned_cut_tbl_.push_back(
783 {from->getImpl()->getOID(), to->getImpl()->getOID()});
784 }
785
786 std::vector<std::pair<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*>>
getPrlForAlignedCutTable() const787 dbTechLayerCutSpacingTableDefRule::getPrlForAlignedCutTable() const
788 {
789 std::vector<std::pair<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*>>
790 res;
791 _dbTechLayerCutSpacingTableDefRule* obj
792 = (_dbTechLayerCutSpacingTableDefRule*) this;
793 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
794 for (auto& [from, to] : obj->prl_for_aligned_cut_tbl_) {
795 res.push_back(
796 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(from),
797 (dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(to)});
798 }
799 return res;
800 }
801
addCenterToCenterEntry(dbTechLayerCutClassRule * from,dbTechLayerCutClassRule * to)802 void dbTechLayerCutSpacingTableDefRule::addCenterToCenterEntry(
803 dbTechLayerCutClassRule* from,
804 dbTechLayerCutClassRule* to)
805 {
806 if (from == nullptr || to == nullptr)
807 return;
808 _dbTechLayerCutSpacingTableDefRule* obj
809 = (_dbTechLayerCutSpacingTableDefRule*) this;
810 obj->center_to_center_tbl_.push_back(
811 {from->getImpl()->getOID(), to->getImpl()->getOID()});
812 }
813
814 std::vector<std::pair<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*>>
getCenterToCenterTable() const815 dbTechLayerCutSpacingTableDefRule::getCenterToCenterTable() const
816 {
817 std::vector<std::pair<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*>>
818 res;
819 _dbTechLayerCutSpacingTableDefRule* obj
820 = (_dbTechLayerCutSpacingTableDefRule*) this;
821 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
822 for (auto& [from, to] : obj->center_to_center_tbl_) {
823 res.push_back(
824 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(from),
825 (dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(to)});
826 }
827 return res;
828 }
829
addCenterAndEdgeEntry(dbTechLayerCutClassRule * from,dbTechLayerCutClassRule * to)830 void dbTechLayerCutSpacingTableDefRule::addCenterAndEdgeEntry(
831 dbTechLayerCutClassRule* from,
832 dbTechLayerCutClassRule* to)
833 {
834 if (from == nullptr || to == nullptr)
835 return;
836 _dbTechLayerCutSpacingTableDefRule* obj
837 = (_dbTechLayerCutSpacingTableDefRule*) this;
838 obj->center_and_edge_tbl_.push_back(
839 {from->getImpl()->getOID(), to->getImpl()->getOID()});
840 }
841
842 std::vector<std::pair<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*>>
getCenterAndEdgeTable() const843 dbTechLayerCutSpacingTableDefRule::getCenterAndEdgeTable() const
844 {
845 std::vector<std::pair<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*>>
846 res;
847 _dbTechLayerCutSpacingTableDefRule* obj
848 = (_dbTechLayerCutSpacingTableDefRule*) this;
849 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
850 for (auto& [from, to] : obj->center_and_edge_tbl_) {
851 res.push_back(
852 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(from),
853 (dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(to)});
854 }
855 return res;
856 }
857
addPrlEntry(dbTechLayerCutClassRule * from,dbTechLayerCutClassRule * to,int ccPrl)858 void dbTechLayerCutSpacingTableDefRule::addPrlEntry(
859 dbTechLayerCutClassRule* from,
860 dbTechLayerCutClassRule* to,
861 int ccPrl)
862 {
863 if (from == nullptr || to == nullptr)
864 return;
865 _dbTechLayerCutSpacingTableDefRule* obj
866 = (_dbTechLayerCutSpacingTableDefRule*) this;
867 obj->prl_tbl_.push_back(
868 {from->getImpl()->getOID(), to->getImpl()->getOID(), ccPrl});
869 }
870
871 std::vector<std::tuple<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*, int>>
getPrlTable() const872 dbTechLayerCutSpacingTableDefRule::getPrlTable() const
873 {
874 std::vector<
875 std::tuple<dbTechLayerCutClassRule*, dbTechLayerCutClassRule*, int>>
876 res;
877 _dbTechLayerCutSpacingTableDefRule* obj
878 = (_dbTechLayerCutSpacingTableDefRule*) this;
879 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
880 for (auto&& [from, to, ccPrl] : obj->prl_tbl_) {
881 res.push_back(
882 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(from),
883 (dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(to),
884 ccPrl});
885 }
886 return res;
887 }
888
addEndExtensionEntry(dbTechLayerCutClassRule * cls,int ext)889 void dbTechLayerCutSpacingTableDefRule::addEndExtensionEntry(
890 dbTechLayerCutClassRule* cls,
891 int ext)
892 {
893 if (cls == nullptr)
894 return;
895 _dbTechLayerCutSpacingTableDefRule* obj
896 = (_dbTechLayerCutSpacingTableDefRule*) this;
897 obj->end_extension_tbl_.push_back({cls->getImpl()->getOID(), ext});
898 }
899
900 std::vector<std::pair<dbTechLayerCutClassRule*, int>>
getEndExtensionTable() const901 dbTechLayerCutSpacingTableDefRule::getEndExtensionTable() const
902 {
903 std::vector<std::pair<dbTechLayerCutClassRule*, int>> res;
904 _dbTechLayerCutSpacingTableDefRule* obj
905 = (_dbTechLayerCutSpacingTableDefRule*) this;
906 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
907 for (auto& [cls, ext] : obj->end_extension_tbl_) {
908 res.push_back(
909 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(cls),
910 ext});
911 }
912 return res;
913 }
914
addSideExtensionEntry(dbTechLayerCutClassRule * cls,int ext)915 void dbTechLayerCutSpacingTableDefRule::addSideExtensionEntry(
916 dbTechLayerCutClassRule* cls,
917 int ext)
918 {
919 if (cls == nullptr)
920 return;
921 _dbTechLayerCutSpacingTableDefRule* obj
922 = (_dbTechLayerCutSpacingTableDefRule*) this;
923 obj->side_extension_tbl_.push_back({cls->getImpl()->getOID(), ext});
924 }
925
926 std::vector<std::pair<dbTechLayerCutClassRule*, int>>
getSideExtensionTable() const927 dbTechLayerCutSpacingTableDefRule::getSideExtensionTable() const
928 {
929 std::vector<std::pair<dbTechLayerCutClassRule*, int>> res;
930 _dbTechLayerCutSpacingTableDefRule* obj
931 = (_dbTechLayerCutSpacingTableDefRule*) this;
932 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
933 for (auto& [cls, ext] : obj->side_extension_tbl_) {
934 res.push_back(
935 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(cls),
936 ext});
937 }
938 return res;
939 }
940
addExactElignedEntry(dbTechLayerCutClassRule * cls,int spacing)941 void dbTechLayerCutSpacingTableDefRule::addExactElignedEntry(
942 dbTechLayerCutClassRule* cls,
943 int spacing)
944 {
945 if (cls == nullptr)
946 return;
947 _dbTechLayerCutSpacingTableDefRule* obj
948 = (_dbTechLayerCutSpacingTableDefRule*) this;
949 obj->exact_aligned_spacing_tbl_.push_back(
950 {cls->getImpl()->getOID(), spacing});
951 }
952
953 std::vector<std::pair<dbTechLayerCutClassRule*, int>>
getExactAlignedTable() const954 dbTechLayerCutSpacingTableDefRule::getExactAlignedTable() const
955 {
956 std::vector<std::pair<dbTechLayerCutClassRule*, int>> res;
957 _dbTechLayerCutSpacingTableDefRule* obj
958 = (_dbTechLayerCutSpacingTableDefRule*) this;
959 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
960 for (auto& [cls, spacing] : obj->exact_aligned_spacing_tbl_) {
961 res.push_back(
962 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(cls),
963 spacing});
964 }
965 return res;
966 }
967
addNonOppEncSpacingEntry(dbTechLayerCutClassRule * cls,int spacing)968 void dbTechLayerCutSpacingTableDefRule::addNonOppEncSpacingEntry(
969 dbTechLayerCutClassRule* cls,
970 int spacing)
971 {
972 if (cls == nullptr)
973 return;
974 _dbTechLayerCutSpacingTableDefRule* obj
975 = (_dbTechLayerCutSpacingTableDefRule*) this;
976 obj->non_opp_enc_spacing_tbl_.push_back({cls->getImpl()->getOID(), spacing});
977 }
978
979 std::vector<std::pair<dbTechLayerCutClassRule*, int>>
getNonOppEncSpacingTable() const980 dbTechLayerCutSpacingTableDefRule::getNonOppEncSpacingTable() const
981 {
982 std::vector<std::pair<dbTechLayerCutClassRule*, int>> res;
983 _dbTechLayerCutSpacingTableDefRule* obj
984 = (_dbTechLayerCutSpacingTableDefRule*) this;
985 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
986 for (auto& [cls, spacing] : obj->non_opp_enc_spacing_tbl_) {
987 res.push_back(
988 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(cls),
989 spacing});
990 }
991 return res;
992 }
993
addOppEncSpacingEntry(dbTechLayerCutClassRule * cls,int rsz1,int rsz2,int spacing)994 void dbTechLayerCutSpacingTableDefRule::addOppEncSpacingEntry(
995 dbTechLayerCutClassRule* cls,
996 int rsz1,
997 int rsz2,
998 int spacing)
999 {
1000 if (cls == nullptr)
1001 return;
1002 _dbTechLayerCutSpacingTableDefRule* obj
1003 = (_dbTechLayerCutSpacingTableDefRule*) this;
1004 obj->opp_enc_spacing_tbl_.push_back(
1005 {cls->getImpl()->getOID(), rsz1, rsz2, spacing});
1006 }
1007
1008 std::vector<std::tuple<dbTechLayerCutClassRule*, int, int, int>>
getOppEncSpacingTable() const1009 dbTechLayerCutSpacingTableDefRule::getOppEncSpacingTable() const
1010 {
1011 std::vector<std::tuple<dbTechLayerCutClassRule*, int, int, int>> res;
1012 _dbTechLayerCutSpacingTableDefRule* obj
1013 = (_dbTechLayerCutSpacingTableDefRule*) this;
1014 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
1015 for (auto& [cls, rsz1, rsz2, spacing] : obj->opp_enc_spacing_tbl_) {
1016 res.push_back(
1017 {(dbTechLayerCutClassRule*) layer->cut_class_rules_tbl_->getPtr(cls),
1018 rsz1,
1019 rsz2,
1020 spacing});
1021 }
1022 return res;
1023 }
1024
getSecondLayer() const1025 dbTechLayer* dbTechLayerCutSpacingTableDefRule::getSecondLayer() const
1026 {
1027 _dbTechLayerCutSpacingTableDefRule* obj
1028 = (_dbTechLayerCutSpacingTableDefRule*) this;
1029 if (obj->second_layer_ == 0)
1030 return nullptr;
1031 _dbTechLayer* layer = (_dbTechLayer*) obj->getOwner();
1032 _dbTech* _tech = (_dbTech*) layer->getOwner();
1033 return (dbTechLayer*) _tech->_layer_tbl->getPtr(obj->second_layer_);
1034 }
1035
setSpacingTable(std::vector<std::vector<std::pair<int,int>>> table,std::map<std::string,uint> row_map,std::map<std::string,uint> col_map)1036 void dbTechLayerCutSpacingTableDefRule::setSpacingTable(
1037 std::vector<std::vector<std::pair<int, int>>> table,
1038 std::map<std::string, uint> row_map,
1039 std::map<std::string, uint> col_map)
1040 {
1041 _dbTechLayerCutSpacingTableDefRule* obj
1042 = (_dbTechLayerCutSpacingTableDefRule*) this;
1043 obj->row_map_ = row_map;
1044 obj->col_map_ = col_map;
1045 for (auto spacing : table) {
1046 dbVector<std::pair<int, int>> tmp;
1047 tmp = spacing;
1048 obj->spacing_tbl_.push_back(tmp);
1049 }
1050 }
1051
getSpacingTable(std::vector<std::vector<std::pair<int,int>>> & table,std::map<std::string,uint> & row_map,std::map<std::string,uint> & col_map)1052 void dbTechLayerCutSpacingTableDefRule::getSpacingTable(
1053 std::vector<std::vector<std::pair<int, int>>>& table,
1054 std::map<std::string, uint>& row_map,
1055 std::map<std::string, uint>& col_map)
1056 {
1057 _dbTechLayerCutSpacingTableDefRule* obj
1058 = (_dbTechLayerCutSpacingTableDefRule*) this;
1059 row_map = obj->row_map_;
1060 col_map = obj->col_map_;
1061 table.clear();
1062 for (auto spacing : obj->spacing_tbl_) {
1063 table.push_back(spacing);
1064 }
1065 }
1066
getSpacing(const char * class1,bool SIDE1,const char * class2,bool SIDE2)1067 std::pair<int, int> dbTechLayerCutSpacingTableDefRule::getSpacing(
1068 const char* class1,
1069 bool SIDE1,
1070 const char* class2,
1071 bool SIDE2)
1072 {
1073 _dbTechLayerCutSpacingTableDefRule* obj
1074 = (_dbTechLayerCutSpacingTableDefRule*) this;
1075 std::string c1 = class1;
1076 std::string c2 = class2;
1077 if (SIDE1)
1078 c1 += "/SIDE";
1079 else
1080 c1 += "/END";
1081
1082 if (SIDE2)
1083 c2 += "/SIDE";
1084 else
1085 c2 += "/END";
1086
1087 if (obj->row_map_.find(c1) != obj->row_map_.end()
1088 && obj->col_map_.find(c2) != obj->col_map_.end())
1089 return obj->spacing_tbl_[obj->row_map_[c1]][obj->col_map_[c2]];
1090 else if (obj->row_map_.find(c2) != obj->row_map_.end()
1091 && obj->col_map_.find(c1) != obj->col_map_.end())
1092 return obj->spacing_tbl_[obj->row_map_[c2]][obj->col_map_[c1]];
1093 else
1094 return {obj->default_, obj->default_};
1095 }
1096
getTechLayer() const1097 dbTechLayer* dbTechLayerCutSpacingTableDefRule::getTechLayer() const
1098 {
1099 _dbTechLayerCutSpacingTableDefRule* obj
1100 = (_dbTechLayerCutSpacingTableDefRule*) this;
1101 return (odb::dbTechLayer*) obj->getOwner();
1102 }
1103
create(dbTechLayer * parent)1104 dbTechLayerCutSpacingTableDefRule* dbTechLayerCutSpacingTableDefRule::create(
1105 dbTechLayer* parent)
1106 {
1107 _dbTechLayer* _parent = (_dbTechLayer*) parent;
1108 _dbTechLayerCutSpacingTableDefRule* newrule
1109 = _parent->cut_spacing_table_def_tbl_->create();
1110 return ((dbTechLayerCutSpacingTableDefRule*) newrule);
1111 }
1112
1113 dbTechLayerCutSpacingTableDefRule*
getTechLayerCutSpacingTableDefSubRule(dbTechLayer * parent,uint dbid)1114 dbTechLayerCutSpacingTableDefRule::getTechLayerCutSpacingTableDefSubRule(
1115 dbTechLayer* parent,
1116 uint dbid)
1117 {
1118 _dbTechLayer* _parent = (_dbTechLayer*) parent;
1119 return (dbTechLayerCutSpacingTableDefRule*)
1120 _parent->cut_spacing_table_def_tbl_->getPtr(dbid);
1121 }
destroy(dbTechLayerCutSpacingTableDefRule * rule)1122 void dbTechLayerCutSpacingTableDefRule::destroy(
1123 dbTechLayerCutSpacingTableDefRule* rule)
1124 {
1125 _dbTechLayer* _parent = (_dbTechLayer*) rule->getImpl()->getOwner();
1126 dbProperty::destroyProperties(rule);
1127 _parent->cut_spacing_table_def_tbl_->destroy(
1128 (_dbTechLayerCutSpacingTableDefRule*) rule);
1129 }
1130
1131 // User Code End dbTechLayerCutSpacingTableDefRulePublicMethods
1132 } // namespace odb
1133 // Generator Code End Cpp
1134