Don't use using odb::Point; in header files to not pollute namespace.

hzeller · hzeller · commit d85597304420 · 2025-10-12T01:01:36.000-07:00
Signed-off-by: Henner Zeller &lt;h.zeller@acm.org&gt;
diff --git a/src/dpl/include/dpl/Opendp.h b/src/dpl/include/dpl/Opendp.h
@@ -35,7 +35,6 @@ using odb::dbInst;
 using odb::dbMaster;
 using odb::dbMasterType;
 using odb::dbTechLayer;
-using odb::Point;
 
 class Node;
 class Group;
diff --git a/src/dpl/src/PlacementDRC.cpp b/src/dpl/src/PlacementDRC.cpp
@@ -26,7 +26,7 @@ odb::Rect transformEdgeRect(const odb::Rect& edge_rect,
   cell->getDbInst()->getMaster()->getPlacementBoundary(bbox);
   odb::dbTransform transform(orient);
   transform.apply(bbox);
-  Point offset(x.v - bbox.xMin(), y.v - bbox.yMin());
+  odb::Point offset(x.v - bbox.xMin(), y.v - bbox.yMin());
   transform.setOffset(offset);
   odb::Rect result(edge_rect);
   transform.apply(result);
diff --git a/src/dpl/src/graphics/Graphics.cpp b/src/dpl/src/graphics/Graphics.cpp
@@ -96,9 +96,9 @@ void Graphics::drawObjects(gui::Painter& painter)
     }
 
     dbBox* bbox = cell->getDbInst()->getBBox();
-    Point initial_location(bbox->xMin(), bbox->yMin());
-    Point final_location(lx.v, ly.v);
-    float len = Point::squaredDistance(initial_location, final_location);
+    odb::Point initial_location(bbox->xMin(), bbox->yMin());
+    odb::Point final_location(lx.v, ly.v);
+    float len = odb::Point::squaredDistance(initial_location, final_location);
     if (len < min_length) {
       continue;
     }
diff --git a/src/dpl/src/graphics/Graphics.h b/src/dpl/src/graphics/Graphics.h
@@ -14,7 +14,6 @@ namespace dpl {
 
 using odb::dbBlock;
 using odb::dbInst;
-using odb::Point;
 
 class Opendp;
 class Node;
diff --git a/src/est/include/est/EstimateParasitics.h b/src/est/include/est/EstimateParasitics.h
@@ -47,7 +47,6 @@ using odb::dbBlock;
 using odb::dbDatabase;
 using odb::dbNet;
 using odb::dbTechLayer;
-using odb::Point;
 
 using stt::SteinerTreeBuilder;
 
@@ -220,8 +219,8 @@ class EstimateParasitics : public dbStaState
 
   ////////////////////////////////////////////////////////////////
   // Returns nullptr if net has less than 2 pins or any pin is not placed.
-  SteinerTree* makeSteinerTree(Point drvr_location,
-                               const std::vector<Point>& sink_locations);
+  SteinerTree* makeSteinerTree(odb::Point drvr_location,
+                               const std::vector<odb::Point>& sink_locations);
   SteinerTree* makeSteinerTree(const Pin* drvr_pin);
   void updateParasitics(bool save_guides = false);
   void ensureWireParasitic(const Pin* drvr_pin);
diff --git a/src/est/include/est/SteinerTree.h b/src/est/include/est/SteinerTree.h
@@ -24,8 +24,6 @@ namespace est {
 
 using utl::Logger;
 
-using odb::Point;
-
 using sta::dbNetwork;
 using sta::hashIncr;
 using sta::Net;
@@ -38,23 +36,23 @@ using stt::SteinerTreeBuilder;
 class PointHash
 {
  public:
-  size_t operator()(const Point& pt) const;
+  size_t operator()(const odb::Point& pt) const;
 };
 
 class PointEqual
 {
  public:
-  bool operator()(const Point& pt1, const Point& pt2) const;
+  bool operator()(const odb::Point& pt1, const odb::Point& pt2) const;
 };
 
 class PinLoc
 {
  public:
   const Pin* pin;
-  Point loc;
+  odb::Point loc;
 };
 
-using LocPinMap = std::unordered_map<Point, PinSeq, PointHash, PointEqual>;
+using LocPinMap = std::unordered_map<odb::Point, PinSeq, PointHash, PointEqual>;
 using SteinerPt = int;
 
 class SteinerTree;
@@ -72,15 +70,15 @@ class SteinerTree
 {
  public:
   SteinerTree(const Pin* drvr_pin, sta::dbNetwork* db_network, Logger* logger);
-  SteinerTree(Point drvr_location, Logger* logger);
+  SteinerTree(odb::Point drvr_location, Logger* logger);
   sta::Vector<PinLoc>& pinlocs() { return pinlocs_; }
   int pinCount() const { return pinlocs_.size(); }
   int branchCount() const;
   void branch(int index,
               // Return values.
-              Point& pt1,
+              odb::Point& pt1,
               int& steiner_pt1,
-              Point& pt2,
+              odb::Point& pt2,
               int& steiner_pt2,
               int& wire_length);
   stt::Branch& branch(int index) { return tree_.branch[index]; }
@@ -111,18 +109,18 @@ class SteinerTree
   const char* name(SteinerPt pt, const Network* network);
   const PinSeq* pins(SteinerPt pt) const;
   const Pin* pin(SteinerPt pt) const;
-  Point location(SteinerPt pt) const;
+  odb::Point location(SteinerPt pt) const;
   void setTree(const stt::Tree& tree);
   void setHasInputPort(bool input_port);
   stt::Tree& fluteTree() { return tree_; }
   void createSteinerPtToPinMap();
-  void locAddPin(const Point& loc, const Pin* pin);
+  void locAddPin(const odb::Point& loc, const Pin* pin);
 
   static constexpr SteinerPt null_pt = -1;
 
  private:
   stt::Tree tree_;
-  const Point drvr_location_;
+  const odb::Point drvr_location_;
   int drvr_steiner_pt_ = 0;      // index into tree_.branch
   sta::Vector<PinLoc> pinlocs_;  // Initial input
   LocPinMap loc_pin_map_;        // location -> pins map
diff --git a/src/est/src/EstimateParasitics.cpp b/src/est/src/EstimateParasitics.cpp
@@ -681,7 +681,7 @@ void EstimateParasitics::estimateWireParasiticSteiner(const Pin* drvr_pin,
       int branch_count = tree->branchCount();
       size_t resistor_id = 1;
       for (int i = 0; i < branch_count; i++) {
-        Point pt1, pt2;
+        odb::Point pt1, pt2;
         SteinerPt steiner_pt1, steiner_pt2;
         int wire_length_dbu;
         tree->branch(i, pt1, steiner_pt1, pt2, steiner_pt2, wire_length_dbu);
@@ -1099,16 +1099,16 @@ static void connectedPins(const Net* net,
     // hit moditerms/modbterms).
     //
     if (iterm || bterm) {
-      Point loc = db_network->location(pin);
+      odb::Point loc = db_network->location(pin);
       pins.push_back({pin, loc});
     }
   }
   delete pin_iter;
 }
 
 SteinerTree* EstimateParasitics::makeSteinerTree(
-    Point drvr_location,
-    const std::vector<Point>& sink_locations)
+    odb::Point drvr_location,
+    const std::vector<odb::Point>& sink_locations)
 {
   SteinerTree* tree = new SteinerTree(drvr_location, logger_);
   sta::Vector<PinLoc>& pinlocs = tree->pinlocs();
diff --git a/src/est/src/SteinerRenderer.cpp b/src/est/src/SteinerRenderer.cpp
@@ -5,6 +5,7 @@
 
 #include "est/SteinerTree.h"
 #include "gui/gui.h"
+#include "odb/geom.h"
 
 namespace est {
 
@@ -23,7 +24,7 @@ void SteinerRenderer::drawObjects(gui::Painter& painter)
   if (tree_) {
     painter.setPen(gui::Painter::kRed, true);
     for (int i = 0; i < tree_->branchCount(); ++i) {
-      Point pt1, pt2;
+      odb::Point pt1, pt2;
       int steiner_pt1, steiner_pt2;
       int wire_length;
       tree_->branch(i, pt1, steiner_pt1, pt2, steiner_pt2, wire_length);
diff --git a/src/est/src/SteinerTree.cpp b/src/est/src/SteinerTree.cpp
@@ -31,7 +31,7 @@ void SteinerTree::setTree(const stt::Tree& tree)
 
   // Find driver steiner point.
   drvr_steiner_pt_ = null_pt;
-  const Point drvr_loc = drvr_location_;
+  const odb::Point drvr_loc = drvr_location_;
   const int drvr_x = drvr_loc.getX();
   const int drvr_y = drvr_loc.getY();
   const int branch_count = tree_.branchCount();
@@ -51,7 +51,7 @@ SteinerTree::SteinerTree(const Pin* drvr_pin,
 {
 }
 
-SteinerTree::SteinerTree(Point drvr_location, Logger* logger)
+SteinerTree::SteinerTree(odb::Point drvr_location, Logger* logger)
     : drvr_location_(drvr_location), logger_(logger)
 {
 }
@@ -75,25 +75,25 @@ int SteinerTree::branchCount() const
   return tree_.branchCount();
 }
 
-void SteinerTree::locAddPin(const Point& loc, const Pin* pin)
+void SteinerTree::locAddPin(const odb::Point& loc, const Pin* pin)
 {
   loc_pin_map_[loc].push_back(pin);
 }
 
 void SteinerTree::branch(int index,
                          // Return values.
-                         Point& pt1,
+                         odb::Point& pt1,
                          int& steiner_pt1,
-                         Point& pt2,
+                         odb::Point& pt2,
                          int& steiner_pt2,
                          int& wire_length)
 {
   stt::Branch& branch_pt1 = tree_.branch[index];
   steiner_pt1 = index;
   steiner_pt2 = branch_pt1.n;
   stt::Branch& branch_pt2 = tree_.branch[steiner_pt2];
-  pt1 = Point(branch_pt1.x, branch_pt1.y);
-  pt2 = Point(branch_pt2.x, branch_pt2.y);
+  pt1 = odb::Point(branch_pt1.x, branch_pt1.y);
+  pt2 = odb::Point(branch_pt2.x, branch_pt2.y);
   wire_length
       = abs(branch_pt1.x - branch_pt2.x) + abs(branch_pt1.y - branch_pt2.y);
 }
@@ -153,10 +153,10 @@ SteinerPt SteinerTree::drvrPt() const
   return drvr_steiner_pt_;
 }
 
-Point SteinerTree::location(const SteinerPt pt) const
+odb::Point SteinerTree::location(const SteinerPt pt) const
 {
   const stt::Branch branch_pt = tree_.branch[pt];
-  return Point(branch_pt.x, branch_pt.y);
+  return odb::Point(branch_pt.x, branch_pt.y);
 }
 
 SteinerPt SteinerTree::top() const
@@ -279,8 +279,8 @@ int SteinerTree::distance(const SteinerPt from, const SteinerPt to) const
   if (from == to) {
     return 0;
   }
-  const Point from_pt = location(from);
-  const Point to_pt = location(to);
+  const odb::Point from_pt = location(from);
+  const odb::Point to_pt = location(to);
   const SteinerPt left_from = left(from);
   const SteinerPt right_from = right(from);
   if (left_from == to || right_from == to) {
@@ -315,15 +315,15 @@ const Pin* SteinerTree::pin(const SteinerPt pt) const
 
 ////////////////////////////////////////////////////////////////
 
-size_t PointHash::operator()(const Point& pt) const
+size_t PointHash::operator()(const odb::Point& pt) const
 {
   size_t hash = sta::hash_init_value;
   hashIncr(hash, pt.x());
   hashIncr(hash, pt.y());
   return hash;
 }
 
-bool PointEqual::operator()(const Point& pt1, const Point& pt2) const
+bool PointEqual::operator()(const odb::Point& pt1, const odb::Point& pt2) const
 {
   return pt1.x() == pt2.x() && pt1.y() == pt2.y();
 }
diff --git a/src/ppl/include/ppl/IOPlacer.h b/src/ppl/include/ppl/IOPlacer.h
@@ -39,8 +39,6 @@ struct Constraint;
 struct Section;
 struct Slot;
 
-using odb::Point;
-
 using utl::Logger;
 
 // A list of pins that will be placed together in the die boundary
@@ -150,10 +148,10 @@ class IOPlacer
                  Edge edge,
                  odb::Line line,
                  bool is_die_polygon);
-  std::vector<Point> findLayerSlots(int layer,
-                                    Edge edge,
-                                    odb::Line line,
-                                    bool is_die_polygon);
+  std::vector<odb::Point> findLayerSlots(int layer,
+                                         Edge edge,
+                                         odb::Line line,
+                                         bool is_die_polygon);
   void initTopLayerGrid();
   void findSlotsForTopLayer();
   void filterObstructedSlotsForTopLayer();
diff --git a/src/ppl/src/Core.h b/src/ppl/src/Core.h
@@ -10,8 +10,6 @@
 
 namespace ppl {
 
-using odb::Point;
-
 using LayerToVector = std::map<int, std::vector<int>>;
 
 class Core
diff --git a/src/ppl/src/HungarianMatching.cpp b/src/ppl/src/HungarianMatching.cpp
@@ -63,7 +63,7 @@ void HungarianMatching::createMatrix()
       std::vector<int> larger_costs;
       int slot_index = 0;
       for (int i = begin_slot_; i <= end_slot_; ++i) {
-        const Point& slot_pos = slots_[i].pos;
+        const odb::Point& slot_pos = slots_[i].pos;
         if (slots_[i].blocked) {
           continue;
         }
@@ -93,7 +93,7 @@ void HungarianMatching::createMatrix()
   }
 }
 
-inline bool samePos(Point& a, Point& b)
+inline bool samePos(odb::Point& a, odb::Point& b)
 {
   return (a.x() == b.x() && a.y() == b.y());
 }
@@ -244,7 +244,7 @@ void HungarianMatching::createMatrixForGroups()
       for (int i : valid_starting_slots_) {
         int group_hpwl = 0;
         for (const int io_idx : pins) {
-          const Point& slot_pos = slots_[i].pos;
+          const odb::Point& slot_pos = slots_[i].pos;
 
           hungarian_matrix_[slot_index].resize(num_pin_groups_,
                                                std::numeric_limits<int>::max());
diff --git a/src/ppl/src/HungarianMatching.h b/src/ppl/src/HungarianMatching.h
@@ -21,7 +21,6 @@ class Logger;
 
 namespace ppl {
 
-using odb::Point;
 using utl::Logger;
 
 class HungarianMatching
diff --git a/src/ppl/src/IOPlacer.cpp b/src/ppl/src/IOPlacer.cpp
diff --git a/src/ppl/src/Netlist.cpp b/src/ppl/src/Netlist.cpp
diff --git a/src/ppl/src/Netlist.h b/src/ppl/src/Netlist.h

Original file line number	Diff line number	Diff line change
`@@ -96,9 +96,9 @@ void Graphics::drawObjects(gui::Painter& painter)`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`dbBox* bbox = cell->getDbInst()->getBBox();`
`99`		`- Point initial_location(bbox->xMin(), bbox->yMin());`
`100`		`- Point final_location(lx.v, ly.v);`
`101`		`- float len = Point::squaredDistance(initial_location, final_location);`
	`99`	`+ odb::Point initial_location(bbox->xMin(), bbox->yMin());`
	`100`	`+ odb::Point final_location(lx.v, ly.v);`
	`101`	`+ float len = odb::Point::squaredDistance(initial_location, final_location);`
`102`	`102`	`if (len < min_length) {`
`103`	`103`	`continue;`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ void SteinerTree::setTree(const stt::Tree& tree)`
`31`	`31`
`32`	`32`	`// Find driver steiner point.`
`33`	`33`	`drvr_steiner_pt_ = null_pt;`
`34`		`- const Point drvr_loc = drvr_location_;`
	`34`	`+ const odb::Point drvr_loc = drvr_location_;`
`35`	`35`	`const int drvr_x = drvr_loc.getX();`
`36`	`36`	`const int drvr_y = drvr_loc.getY();`
`37`	`37`	`const int branch_count = tree_.branchCount();`
`@@ -51,7 +51,7 @@ SteinerTree::SteinerTree(const Pin* drvr_pin,`
`51`	`51`	`{`
`52`	`52`	`}`
`53`	`53`
`54`		`-SteinerTree::SteinerTree(Point drvr_location, Logger* logger)`
	`54`	`+SteinerTree::SteinerTree(odb::Point drvr_location, Logger* logger)`
`55`	`55`	`: drvr_location_(drvr_location), logger_(logger)`
`56`	`56`	`{`
`57`	`57`	`}`
`@@ -75,25 +75,25 @@ int SteinerTree::branchCount() const`
`75`	`75`	`return tree_.branchCount();`
`76`	`76`	`}`
`77`	`77`
`78`		`-void SteinerTree::locAddPin(const Point& loc, const Pin* pin)`
	`78`	`+void SteinerTree::locAddPin(const odb::Point& loc, const Pin* pin)`
`79`	`79`	`{`
`80`	`80`	`loc_pin_map_[loc].push_back(pin);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`void SteinerTree::branch(int index,`
`84`	`84`	`// Return values.`
`85`		`- Point& pt1,`
	`85`	`+ odb::Point& pt1,`
`86`	`86`	`int& steiner_pt1,`
`87`		`- Point& pt2,`
	`87`	`+ odb::Point& pt2,`
`88`	`88`	`int& steiner_pt2,`
`89`	`89`	`int& wire_length)`
`90`	`90`	`{`
`91`	`91`	`stt::Branch& branch_pt1 = tree_.branch[index];`
`92`	`92`	`steiner_pt1 = index;`
`93`	`93`	`steiner_pt2 = branch_pt1.n;`
`94`	`94`	`stt::Branch& branch_pt2 = tree_.branch[steiner_pt2];`
`95`		`- pt1 = Point(branch_pt1.x, branch_pt1.y);`
`96`		`- pt2 = Point(branch_pt2.x, branch_pt2.y);`
	`95`	`+ pt1 = odb::Point(branch_pt1.x, branch_pt1.y);`
	`96`	`+ pt2 = odb::Point(branch_pt2.x, branch_pt2.y);`
`97`	`97`	`wire_length`
`98`	`98`	`= abs(branch_pt1.x - branch_pt2.x) + abs(branch_pt1.y - branch_pt2.y);`
`99`	`99`	`}`
`@@ -153,10 +153,10 @@ SteinerPt SteinerTree::drvrPt() const`
`153`	`153`	`return drvr_steiner_pt_;`
`154`	`154`	`}`
`155`	`155`
`156`		`-Point SteinerTree::location(const SteinerPt pt) const`
	`156`	`+odb::Point SteinerTree::location(const SteinerPt pt) const`
`157`	`157`	`{`
`158`	`158`	`const stt::Branch branch_pt = tree_.branch[pt];`
`159`		`- return Point(branch_pt.x, branch_pt.y);`
	`159`	`+ return odb::Point(branch_pt.x, branch_pt.y);`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`SteinerPt SteinerTree::top() const`
`@@ -279,8 +279,8 @@ int SteinerTree::distance(const SteinerPt from, const SteinerPt to) const`
`279`	`279`	`if (from == to) {`
`280`	`280`	`return 0;`
`281`	`281`	`}`
`282`		`- const Point from_pt = location(from);`
`283`		`- const Point to_pt = location(to);`
	`282`	`+ const odb::Point from_pt = location(from);`
	`283`	`+ const odb::Point to_pt = location(to);`
`284`	`284`	`const SteinerPt left_from = left(from);`
`285`	`285`	`const SteinerPt right_from = right(from);`
`286`	`286`	`if (left_from == to \|\| right_from == to) {`
`@@ -315,15 +315,15 @@ const Pin* SteinerTree::pin(const SteinerPt pt) const`
`315`	`315`
`316`	`316`	`////////////////////////////////////////////////////////////////`
`317`	`317`
`318`		`-size_t PointHash::operator()(const Point& pt) const`
	`318`	`+size_t PointHash::operator()(const odb::Point& pt) const`
`319`	`319`	`{`
`320`	`320`	`size_t hash = sta::hash_init_value;`
`321`	`321`	`hashIncr(hash, pt.x());`
`322`	`322`	`hashIncr(hash, pt.y());`
`323`	`323`	`return hash;`
`324`	`324`	`}`
`325`	`325`
`326`		`-bool PointEqual::operator()(const Point& pt1, const Point& pt2) const`
	`326`	`+bool PointEqual::operator()(const odb::Point& pt1, const odb::Point& pt2) const`
`327`	`327`	`{`
`328`	`328`	`return pt1.x() == pt2.x() && pt1.y() == pt2.y();`
`329`	`329`	`}`