odb: update some internal class names to not use a leading underscore

maliberty · maliberty · commit 7e5fb58c20c0 · 2025-12-03T17:19:05.000Z
Signed-off-by: Matt Liberty &lt;mliberty@precisioninno.com&gt;
diff --git a/src/odb/src/db/dbTechLayerAntennaRule.cpp b/src/odb/src/db/dbTechLayerAntennaRule.cpp
@@ -26,7 +26,7 @@ template class dbTable<_dbTechAntennaPinModel>;
 
 using std::vector;
 
-bool _ARuleFactor::operator==(const _ARuleFactor& rhs) const
+bool ARuleFactor::operator==(const ARuleFactor& rhs) const
 {
   if (_factor != rhs._factor) {
     return false;
@@ -43,7 +43,7 @@ bool _ARuleFactor::operator==(const _ARuleFactor& rhs) const
   return true;
 }
 
-bool _ARuleRatio::operator==(const _ARuleRatio& rhs) const
+bool ARuleRatio::operator==(const ARuleRatio& rhs) const
 {
   if (_ratio != rhs._ratio) {
     return false;
@@ -151,27 +151,27 @@ bool _dbTechAntennaPinModel::operator==(const _dbTechAntennaPinModel& rhs) const
 
 ////////////////////////////////////////////////////////////////////
 //
-// _ARuleFactor - Methods
+// ARuleFactor - Methods
 //
 ////////////////////////////////////////////////////////////////////
 
-void _ARuleFactor::setFactor(double factor, bool diffuse)
+void ARuleFactor::setFactor(double factor, bool diffuse)
 {
   assert(factor > 0.0);
   _factor = factor;
   _diff_use_only = diffuse;
   _explicit = true;
 }
 
-dbOStream& operator<<(dbOStream& stream, const _ARuleFactor& arf)
+dbOStream& operator<<(dbOStream& stream, const ARuleFactor& arf)
 {
   stream << arf._factor;
   stream << arf._explicit;
   stream << arf._diff_use_only;
   return stream;
 }
 
-dbIStream& operator>>(dbIStream& stream, _ARuleFactor& arf)
+dbIStream& operator>>(dbIStream& stream, ARuleFactor& arf)
 {
   stream >> arf._factor;
   stream >> arf._explicit;
@@ -181,41 +181,41 @@ dbIStream& operator>>(dbIStream& stream, _ARuleFactor& arf)
 
 ////////////////////////////////////////////////////////////////////
 //
-// _ARuleRatio - Methods
+// ARuleRatio - Methods
 //
 ////////////////////////////////////////////////////////////////////
 
-void _ARuleRatio::setRatio(double ratio)
+void ARuleRatio::setRatio(double ratio)
 {
   assert(ratio > 0);
   _ratio = ratio;
 }
 
-void _ARuleRatio::setDiff(double ratio)
+void ARuleRatio::setDiff(double ratio)
 {
   assert(ratio > 0);
   assert((_diff_idx.size() == 0) && (_diff_ratio.size() == 0));
   _diff_idx.assign(1, 0.0);
   _diff_ratio.assign(1, ratio);
 }
 
-void _ARuleRatio::setDiff(const vector<double>& diff_idx,
+void ARuleRatio::setDiff(const vector<double>& diff_idx,
                           const vector<double>& ratios)
 {
   assert((_diff_idx.size() == 0) && (_diff_ratio.size() == 0));
   _diff_idx = diff_idx;
   _diff_ratio = ratios;
 }
 
-dbOStream& operator<<(dbOStream& stream, const _ARuleRatio& arrt)
+dbOStream& operator<<(dbOStream& stream, const ARuleRatio& arrt)
 {
   stream << arrt._ratio;
   stream << arrt._diff_idx;
   stream << arrt._diff_ratio;
   return stream;
 }
 
-dbIStream& operator>>(dbIStream& stream, _ARuleRatio& arrt)
+dbIStream& operator>>(dbIStream& stream, ARuleRatio& arrt)
 {
   stream >> arrt._ratio;
   stream >> arrt._diff_idx;
diff --git a/src/odb/src/db/dbTechLayerAntennaRule.h b/src/odb/src/db/dbTechLayerAntennaRule.h
@@ -28,35 +28,35 @@ class lefout;
 // An antenna multiplier factor is applied to metal. A separate factor may
 // be used for diffusion connected metal.
 //
-class _ARuleFactor
+class ARuleFactor
 {
  public:
   double _factor;
   bool _explicit;
   bool _diff_use_only;
 
-  _ARuleFactor();
+  ARuleFactor();
   void setFactor(double factor, bool diffuse);
-  bool operator==(const _ARuleFactor& rhs) const;
-  bool operator!=(const _ARuleFactor& rhs) const { return !operator==(rhs); }
+  bool operator==(const ARuleFactor& rhs) const;
+  bool operator!=(const ARuleFactor& rhs) const { return !operator==(rhs); }
 };
 
-inline _ARuleFactor::_ARuleFactor()
+inline ARuleFactor::ARuleFactor()
 {
   _factor = 1.0;
   _explicit = false;
   _diff_use_only = false;
 }
 
-dbOStream& operator<<(dbOStream& stream, const _ARuleFactor& arf);
-dbIStream& operator>>(dbIStream& stream, _ARuleFactor& arf);
+dbOStream& operator<<(dbOStream& stream, const ARuleFactor& arf);
+dbIStream& operator>>(dbIStream& stream, ARuleFactor& arf);
 
 //
 // An antenna rule ratio is a single ratio for non-diffusion connected segments
 // or a piecewise linear function of diffusion area for diffusion connected
 // segments.
 //
-class _ARuleRatio
+class ARuleRatio
 {
  public:
   double _ratio{0.0};
@@ -68,12 +68,12 @@ class _ARuleRatio
                const std::vector<double>& ratios);
   void setDiff(double ratio);  // single value stored as PWL
 
-  bool operator==(const _ARuleRatio& rhs) const;
-  bool operator!=(const _ARuleRatio& rhs) const { return !operator==(rhs); }
+  bool operator==(const ARuleRatio& rhs) const;
+  bool operator!=(const ARuleRatio& rhs) const { return !operator==(rhs); }
 };
 
-dbOStream& operator<<(dbOStream& stream, const _ARuleRatio& arrt);
-dbIStream& operator>>(dbIStream& stream, _ARuleRatio& arrt);
+dbOStream& operator<<(dbOStream& stream, const ARuleRatio& arrt);
+dbIStream& operator>>(dbIStream& stream, ARuleRatio& arrt);
 
 ///  An antenna rule comprises a multiplier factor for area and sidearea
 ///  (perimeter), as well as ratios for the area and sidearea for both
@@ -83,13 +83,13 @@ class _dbTechLayerAntennaRule : public _dbObject
 {
  public:
   dbId<_dbTechLayer> _layer;
-  _ARuleFactor _area_mult;
-  _ARuleFactor _sidearea_mult;
-  _ARuleRatio _par_area_val;
-  _ARuleRatio _cum_area_val;
-  _ARuleRatio _par_sidearea_val;
-  _ARuleRatio _cum_sidearea_val;
-  _ARuleRatio _area_diff_reduce_val;
+  ARuleFactor _area_mult;
+  ARuleFactor _sidearea_mult;
+  ARuleRatio _par_area_val;
+  ARuleRatio _cum_area_val;
+  ARuleRatio _par_sidearea_val;
+  ARuleRatio _cum_sidearea_val;
+  ARuleRatio _area_diff_reduce_val;
   double _gate_plus_diff_factor;
   double _area_minus_diff_factor;
   bool _has_antenna_cumroutingpluscut;
diff --git a/src/odb/src/db/dbTechLayerSpacingRule.h b/src/odb/src/db/dbTechLayerSpacingRule.h
@@ -18,7 +18,7 @@ class dbOStream;
 class _dbTechLayerSpacingRule : public _dbObject
 {
  public:
-  enum _RuleType
+  enum RuleType
   {
     kDefault = 0,
     kRangeOnly,
@@ -35,9 +35,9 @@ class _dbTechLayerSpacingRule : public _dbObject
     kEndOfLineParallelTwoEdges
   };
 
-  struct _Flword
+  struct Flags
   {
-    _RuleType _rule : 4;
+    RuleType _rule : 4;
     bool _except_same_pgnet : 1;
     bool _cut_stacking : 1;
     bool _cut_center_to_center : 1;
@@ -49,7 +49,7 @@ class _dbTechLayerSpacingRule : public _dbObject
   };
 
   // PERSISTENT-MEMBERS
-  _Flword flags_;
+  Flags flags_;
   uint _spacing;
   uint _length_or_influence;
   uint _r1min;
diff --git a/src/odb/src/db/dbTechMinCutOrAreaRule.h b/src/odb/src/db/dbTechMinCutOrAreaRule.h
@@ -19,21 +19,21 @@ class _dbTechMinCutRule : public _dbObject
 {
  public:
   // PERSISTENT-MEMBERS
-  enum _RuleType
+  enum RuleType
   {
     kNone,
     kMinimumCut,
     kMinimumCutAbove,
     kMinimumCutBelow
   };
 
-  struct _Flword
+  struct Flags
   {
-    _RuleType _rule : 3;
+    RuleType _rule : 3;
     uint _cuts_length : 1;
     uint _spare_bits : 28;
   };
-  _Flword flags_;
+  Flags flags_;
   uint _num_cuts;
   uint _width;
   int _cut_distance;
@@ -87,12 +87,13 @@ class _dbTechMinEncRule : public _dbObject
  public:
   // PERSISTENT-MEMBERS
 
-  struct _Flword
+  struct Flags
   {
     uint _has_width : 1;
     uint _spare_bits : 31;
-  } flags_;
+  };
 
+  Flags  flags_;
   uint _area;
   uint _width;
 

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ template class dbTable<_dbTechAntennaPinModel>;`
`26`	`26`
`27`	`27`	`using std::vector;`
`28`	`28`
`29`		`-bool _ARuleFactor::operator==(const _ARuleFactor& rhs) const`
	`29`	`+bool ARuleFactor::operator==(const ARuleFactor& rhs) const`
`30`	`30`	`{`
`31`	`31`	`if (_factor != rhs._factor) {`
`32`	`32`	`return false;`
`@@ -43,7 +43,7 @@ bool _ARuleFactor::operator==(const _ARuleFactor& rhs) const`
`43`	`43`	`return true;`
`44`	`44`	`}`
`45`	`45`
`46`		`-bool _ARuleRatio::operator==(const _ARuleRatio& rhs) const`
	`46`	`+bool ARuleRatio::operator==(const ARuleRatio& rhs) const`
`47`	`47`	`{`
`48`	`48`	`if (_ratio != rhs._ratio) {`
`49`	`49`	`return false;`
`@@ -151,27 +151,27 @@ bool _dbTechAntennaPinModel::operator==(const _dbTechAntennaPinModel& rhs) const`
`151`	`151`
`152`	`152`	`////////////////////////////////////////////////////////////////////`
`153`	`153`	`//`
`154`		`-// _ARuleFactor - Methods`
	`154`	`+// ARuleFactor - Methods`
`155`	`155`	`//`
`156`	`156`	`////////////////////////////////////////////////////////////////////`
`157`	`157`
`158`		`-void _ARuleFactor::setFactor(double factor, bool diffuse)`
	`158`	`+void ARuleFactor::setFactor(double factor, bool diffuse)`
`159`	`159`	`{`
`160`	`160`	`assert(factor > 0.0);`
`161`	`161`	`_factor = factor;`
`162`	`162`	`_diff_use_only = diffuse;`
`163`	`163`	`_explicit = true;`
`164`	`164`	`}`
`165`	`165`
`166`		`-dbOStream& operator<<(dbOStream& stream, const _ARuleFactor& arf)`
	`166`	`+dbOStream& operator<<(dbOStream& stream, const ARuleFactor& arf)`
`167`	`167`	`{`
`168`	`168`	`stream << arf._factor;`
`169`	`169`	`stream << arf._explicit;`
`170`	`170`	`stream << arf._diff_use_only;`
`171`	`171`	`return stream;`
`172`	`172`	`}`
`173`	`173`
`174`		`-dbIStream& operator>>(dbIStream& stream, _ARuleFactor& arf)`
	`174`	`+dbIStream& operator>>(dbIStream& stream, ARuleFactor& arf)`
`175`	`175`	`{`
`176`	`176`	`stream >> arf._factor;`
`177`	`177`	`stream >> arf._explicit;`
`@@ -181,41 +181,41 @@ dbIStream& operator>>(dbIStream& stream, _ARuleFactor& arf)`
`181`	`181`
`182`	`182`	`////////////////////////////////////////////////////////////////////`
`183`	`183`	`//`
`184`		`-// _ARuleRatio - Methods`
	`184`	`+// ARuleRatio - Methods`
`185`	`185`	`//`
`186`	`186`	`////////////////////////////////////////////////////////////////////`
`187`	`187`
`188`		`-void _ARuleRatio::setRatio(double ratio)`
	`188`	`+void ARuleRatio::setRatio(double ratio)`
`189`	`189`	`{`
`190`	`190`	`assert(ratio > 0);`
`191`	`191`	`_ratio = ratio;`
`192`	`192`	`}`
`193`	`193`
`194`		`-void _ARuleRatio::setDiff(double ratio)`
	`194`	`+void ARuleRatio::setDiff(double ratio)`
`195`	`195`	`{`
`196`	`196`	`assert(ratio > 0);`
`197`	`197`	`assert((_diff_idx.size() == 0) && (_diff_ratio.size() == 0));`
`198`	`198`	`_diff_idx.assign(1, 0.0);`
`199`	`199`	`_diff_ratio.assign(1, ratio);`
`200`	`200`	`}`
`201`	`201`
`202`		`-void _ARuleRatio::setDiff(const vector<double>& diff_idx,`
	`202`	`+void ARuleRatio::setDiff(const vector<double>& diff_idx,`
`203`	`203`	`const vector<double>& ratios)`
`204`	`204`	`{`
`205`	`205`	`assert((_diff_idx.size() == 0) && (_diff_ratio.size() == 0));`
`206`	`206`	`_diff_idx = diff_idx;`
`207`	`207`	`_diff_ratio = ratios;`
`208`	`208`	`}`
`209`	`209`
`210`		`-dbOStream& operator<<(dbOStream& stream, const _ARuleRatio& arrt)`
	`210`	`+dbOStream& operator<<(dbOStream& stream, const ARuleRatio& arrt)`
`211`	`211`	`{`
`212`	`212`	`stream << arrt._ratio;`
`213`	`213`	`stream << arrt._diff_idx;`
`214`	`214`	`stream << arrt._diff_ratio;`
`215`	`215`	`return stream;`
`216`	`216`	`}`
`217`	`217`
`218`		`-dbIStream& operator>>(dbIStream& stream, _ARuleRatio& arrt)`
	`218`	`+dbIStream& operator>>(dbIStream& stream, ARuleRatio& arrt)`
`219`	`219`	`{`
`220`	`220`	`stream >> arrt._ratio;`
`221`	`221`	`stream >> arrt._diff_idx;`