1 ///////////////////////////////////////////////////////////////////////////////
2 // BSD 3-Clause License
3 //
4 // Copyright (c) 2019, Nefelus Inc
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 #include "dbTechSameNetRule.h"
34
35 #include "db.h"
36 #include "dbDatabase.h"
37 #include "dbTable.h"
38 #include "dbTable.hpp"
39 #include "dbTech.h"
40 #include "dbTechLayer.h"
41 #include "dbTechNonDefaultRule.h"
42
43 namespace odb {
44
45 template class dbTable<_dbTechSameNetRule>;
46
operator ==(const _dbTechSameNetRule & rhs) const47 bool _dbTechSameNetRule::operator==(const _dbTechSameNetRule& rhs) const
48 {
49 if (_flags._stack != rhs._flags._stack)
50 return false;
51
52 if (_spacing != rhs._spacing)
53 return false;
54
55 if (_layer_1 != rhs._layer_1)
56 return false;
57
58 if (_layer_2 != rhs._layer_2)
59 return false;
60
61 return true;
62 }
63
differences(dbDiff & diff,const char * field,const _dbTechSameNetRule & rhs) const64 void _dbTechSameNetRule::differences(dbDiff& diff,
65 const char* field,
66 const _dbTechSameNetRule& rhs) const
67 {
68 DIFF_BEGIN
69 DIFF_FIELD(_flags._stack);
70 DIFF_FIELD(_spacing);
71 DIFF_FIELD(_layer_1);
72 DIFF_FIELD(_layer_2);
73 DIFF_END
74 }
75
out(dbDiff & diff,char side,const char * field) const76 void _dbTechSameNetRule::out(dbDiff& diff, char side, const char* field) const
77 {
78 DIFF_OUT_BEGIN
79 DIFF_OUT_FIELD(_flags._stack);
80 DIFF_OUT_FIELD(_spacing);
81 DIFF_OUT_FIELD(_layer_1);
82 DIFF_OUT_FIELD(_layer_2);
83 DIFF_END
84 }
85
86 ////////////////////////////////////////////////////////////////////
87 //
88 // dbTechSameNetRule - Methods
89 //
90 ////////////////////////////////////////////////////////////////////
91
getLayer1()92 dbTechLayer* dbTechSameNetRule::getLayer1()
93 {
94 _dbTechSameNetRule* rule = (_dbTechSameNetRule*) this;
95 _dbTech* tech = (_dbTech*) rule->getOwner();
96 return (dbTechLayer*) tech->_layer_tbl->getPtr(rule->_layer_1);
97 }
98
getLayer2()99 dbTechLayer* dbTechSameNetRule::getLayer2()
100 {
101 _dbTechSameNetRule* rule = (_dbTechSameNetRule*) this;
102 _dbTech* tech = (_dbTech*) rule->getOwner();
103 return (dbTechLayer*) tech->_layer_tbl->getPtr(rule->_layer_2);
104 }
105
getSpacing()106 int dbTechSameNetRule::getSpacing()
107 {
108 _dbTechSameNetRule* rule = (_dbTechSameNetRule*) this;
109 return rule->_spacing;
110 }
111
setSpacing(int spacing)112 void dbTechSameNetRule::setSpacing(int spacing)
113 {
114 _dbTechSameNetRule* rule = (_dbTechSameNetRule*) this;
115 rule->_spacing = spacing;
116 }
117
setAllowStackedVias(bool value)118 void dbTechSameNetRule::setAllowStackedVias(bool value)
119 {
120 _dbTechSameNetRule* rule = (_dbTechSameNetRule*) this;
121
122 if (value)
123 rule->_flags._stack = 1;
124 else
125 rule->_flags._stack = 0;
126 }
127
getAllowStackedVias()128 bool dbTechSameNetRule::getAllowStackedVias()
129 {
130 _dbTechSameNetRule* rule = (_dbTechSameNetRule*) this;
131 return rule->_flags._stack == 1;
132 }
133
create(dbTechLayer * layer1_,dbTechLayer * layer2_)134 dbTechSameNetRule* dbTechSameNetRule::create(dbTechLayer* layer1_,
135 dbTechLayer* layer2_)
136 {
137 _dbTechLayer* layer1 = (_dbTechLayer*) layer1_;
138 _dbTechLayer* layer2 = (_dbTechLayer*) layer2_;
139 dbTech* tech_ = (dbTech*) layer1->getOwner();
140 _dbTech* tech = (_dbTech*) tech_;
141 assert(tech_ == (dbTech*) layer2->getOwner());
142
143 if (tech->_samenet_rules.size() == 0)
144 tech->_samenet_matrix.resize(tech->_layer_cnt, tech->_layer_cnt);
145
146 else if (tech_->findSameNetRule(layer1_, layer2_))
147 return NULL;
148
149 _dbTechSameNetRule* rule = tech->_samenet_rule_tbl->create();
150 rule->_layer_1 = layer1->getOID();
151 rule->_layer_2 = layer2->getOID();
152 tech->_samenet_matrix(layer1->_number, layer2->_number) = rule->getOID();
153 tech->_samenet_matrix(layer2->_number, layer1->_number) = rule->getOID();
154 tech->_samenet_rules.push_back(rule->getOID());
155 return (dbTechSameNetRule*) rule;
156 }
157
create(dbTechNonDefaultRule * ndrule_,dbTechLayer * layer1_,dbTechLayer * layer2_)158 dbTechSameNetRule* dbTechSameNetRule::create(dbTechNonDefaultRule* ndrule_,
159 dbTechLayer* layer1_,
160 dbTechLayer* layer2_)
161 {
162 _dbTechNonDefaultRule* ndrule = (_dbTechNonDefaultRule*) ndrule_;
163 _dbTechLayer* layer1 = (_dbTechLayer*) layer1_;
164 _dbTechLayer* layer2 = (_dbTechLayer*) layer2_;
165 dbTech* tech_ = (dbTech*) layer1->getOwner();
166 _dbTech* tech = (_dbTech*) tech_;
167 assert(tech_ == (dbTech*) layer2->getOwner());
168 assert(tech_ == (dbTech*) ndrule->getOwner());
169
170 if (ndrule->_samenet_rules.size() == 0)
171 ndrule->_samenet_matrix.resize(tech->_layer_cnt, tech->_layer_cnt);
172
173 else if (ndrule_->findSameNetRule(layer1_, layer2_))
174 return NULL;
175
176 _dbTechSameNetRule* rule = tech->_samenet_rule_tbl->create();
177 rule->_layer_1 = layer1->getOID();
178 rule->_layer_2 = layer2->getOID();
179 ndrule->_samenet_matrix(layer1->_number, layer2->_number) = rule->getOID();
180 ndrule->_samenet_matrix(layer2->_number, layer1->_number) = rule->getOID();
181 ndrule->_samenet_rules.push_back(rule->getOID());
182 return (dbTechSameNetRule*) rule;
183 }
184
getTechSameNetRule(dbTech * tech_,uint dbid_)185 dbTechSameNetRule* dbTechSameNetRule::getTechSameNetRule(dbTech* tech_,
186 uint dbid_)
187 {
188 _dbTech* tech = (_dbTech*) tech_;
189 return (dbTechSameNetRule*) tech->_samenet_rule_tbl->getPtr(dbid_);
190 }
191
192 } // namespace odb
193