odb: dbTransform smal fixes

Signed-off-by: osamahammad21 <[email protected]>

Author: osamahammad21

src/odb/include/odb/dbTransform.h

@@ -18,66 +18,66 @@ class dbIStream;
 class dbTransform
 {
   friend class _dbBlock;
-  dbOrientType::Value _orient = dbOrientType::R0;
-  Point3D _offset;
+  dbOrientType::Value orient_ = dbOrientType::R0;
+  Point3D offset_;
   bool mirror_z_ = false;
 
  public:
   // T = <R0, (0,0,0), false>
   dbTransform() = default;
 
   //  T = <R0, (offset,0), false>
-  dbTransform(const Point offset) : _offset(offset, 0) {}
+  dbTransform(const Point offset) : offset_(offset, 0) {}
 
   //  T = <R0, offset, false>
-  dbTransform(const Point3D& offset) : _offset(offset) {}
+  dbTransform(const Point3D& offset) : offset_(offset) {}
 
   //  T = <orient, (0,0,0), false>
-  dbTransform(const dbOrientType orient) : _orient(orient) {}
+  dbTransform(const dbOrientType orient) : orient_(orient) {}
 
   //  T = <orient, (0,0,0), orient.mirror_z_>
   dbTransform(const dbOrientType3D& orient)
-      : _orient(orient.getOrientType2D()), mirror_z_(orient.isMirrorZ())
+      : orient_(orient.getOrientType2D()), mirror_z_(orient.isMirrorZ())
   {
   }
 
   //  T = <orient, (offset,0), false>
   dbTransform(const dbOrientType orient, const Point& offset)
-      : _orient(orient), _offset(offset, 0)
+      : orient_(orient), offset_(offset, 0)
   {
   }
 
   dbTransform(const dbOrientType3D orient, const Point3D& offset)
-      : _orient(orient.getOrientType2D()),
-        _offset(offset),
+      : orient_(orient.getOrientType2D()),
+        offset_(offset),
         mirror_z_(orient.isMirrorZ())
   {
   }
 
   bool operator==(const dbTransform& t) const
   {
-    return (_orient == t._orient) && (_offset == t._offset)
+    return (orient_ == t.orient_) && (offset_ == t.offset_)
            && (mirror_z_ == t.mirror_z_);
   }
 
   bool operator!=(const dbTransform& t) const { return !operator==(t); }
 
-  void setOrient(const dbOrientType orient) { _orient = orient; }
+  void setOrient(const dbOrientType orient) { orient_ = orient; }
 
   void setOrient(const dbOrientType3D& orient)
   {
-    _orient = orient.getOrientType2D();
+    orient_ = orient.getOrientType2D();
     mirror_z_ = orient.isMirrorZ();
   }
 
-  void setOffset(const Point offset) { _offset = Point3D(offset, 0); }
+  void setOffset(const Point offset) { offset_ = Point3D(offset, 0); }
 
-  void setOffset(const Point3D& offset) { _offset = offset; }
+  void setOffset(const Point3D& offset) { offset_ = offset; }
 
   void setTransform(const dbOrientType orient, const Point& offset)
   {
-    _orient = orient;
-    _offset = Point3D(offset, 0);
+    orient_ = orient;
+    offset_ = Point3D(offset, 0);
   }
 
   // Apply transform to this point
@@ -107,8 +107,8 @@ class dbTransform
   // Compute inverse transform
   void invert();
 
-  dbOrientType getOrient() const { return _orient; }
-  Point getOffset() const { return Point(_offset.x(), _offset.y()); }
+  dbOrientType getOrient() const { return orient_; }
+  Point getOffset() const { return Point(offset_.x(), offset_.y()); }
 
   friend dbOStream& operator<<(dbOStream& stream, const dbTransform& t);
   friend dbIStream& operator>>(dbIStream& stream, dbTransform& t);

src/odb/src/db/dbTransform.cpp

@@ -81,17 +81,17 @@ static const dbOrientType::Value orientMul[8][8] = {{dbOrientType::R0,
 
 dbOStream& operator<<(dbOStream& stream, const dbTransform& t)
 {
-  stream << (int) t._orient;
-  stream << t._offset;
+  stream << (int) t.orient_;
+  stream << t.offset_;
   return stream;
 }
 
 dbIStream& operator>>(dbIStream& stream, dbTransform& t)
 {
   int orient;
   stream >> orient;
-  t._orient = (dbOrientType::Value) orient;
-  stream >> t._offset;
+  t.orient_ = (dbOrientType::Value) orient;
+  stream >> t.offset_;
   return stream;
 }
 
@@ -112,10 +112,10 @@ dbIStream& operator>>(dbIStream& stream, dbTransform& t)
 //
 void dbTransform::invert(dbTransform& result) const
 {
-  Point offset(-_offset.x(), -_offset.y());
+  Point offset(-offset_.x(), -offset_.y());
   dbOrientType::Value orient;
 
-  switch (_orient) {
+  switch (orient_) {
     case dbOrientType::R0:
       orient = dbOrientType::R0;
       break;
@@ -160,14 +160,14 @@ void dbTransform::invert(dbTransform& result) const
       throw std::runtime_error("Unknown orientation");
   }
 
-  result._offset = Point3D(offset, mirror_z_ ? _offset.z() : -_offset.z());
-  result._orient = orient;
+  result.offset_ = Point3D(offset, mirror_z_ ? offset_.z() : -offset_.z());
+  result.orient_ = orient;
   result.mirror_z_ = mirror_z_;
 }
 
 void dbTransform::apply(Point& p) const
 {
-  switch (_orient) {
+  switch (orient_) {
     case dbOrientType::R0:
       break;
 
@@ -202,8 +202,8 @@ void dbTransform::apply(Point& p) const
       break;
   }
 
-  p.addX(_offset.x());
-  p.addY(_offset.y());
+  p.addX(offset_.x());
+  p.addY(offset_.y());
 }
 
 void dbTransform::apply(Point3D& p) const
@@ -218,7 +218,7 @@ void dbTransform::apply(Point3D& p) const
 
   p.setX(p2d.x());
   p.setY(p2d.y());
-  p.setZ(z + _offset.z());
+  p.setZ(z + offset_.z());
 }
 
 void dbTransform::apply(Rect& r) const
@@ -250,9 +250,9 @@ void dbTransform::apply(Polygon& p) const
 
 void dbTransform::concat(const dbTransform& t, dbTransform& result)
 {
-  result._offset = _offset;
-  t.apply(result._offset);
-  result._orient = orientMul[_orient][t._orient];
+  result.offset_ = offset_;
+  t.apply(result.offset_);
+  result.orient_ = orientMul[orient_][t.orient_];
   result.mirror_z_ = mirror_z_ ^ t.mirror_z_;
 }