odb: near final progress on naming style (trailing underscore)

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

src/gui/src/search.cpp

@@ -481,7 +481,7 @@ void Search::addNet(
 
   for (itr.begin(wire); itr.next(s);) {
     if (s.isVia()) {
-      addVia(net, &s, itr._prev_x, itr._prev_y, tree_shapes);
+      addVia(net, &s, itr.prev_x_, itr.prev_y_, tree_shapes);
     } else {
       tree_shapes[s.getTechLayer()].emplace_back(s.getBox(), WIRE, net);
     }

src/odb/include/odb/dbBlockCallBackObj.h

@@ -203,14 +203,14 @@ class dbBlockCallBackObj
 
   // Manipulate _callback list of owner -- in journal.cpp
   void addOwner(dbBlock* new_owner);
-  bool hasOwner() const { return (_owner != nullptr); }
+  bool hasOwner() const { return (owner_ != nullptr); }
   void removeOwner();
 
-  dbBlockCallBackObj() { _owner = nullptr; }
+  dbBlockCallBackObj() { owner_ = nullptr; }
   virtual ~dbBlockCallBackObj() { removeOwner(); }
 
  private:
-  dbBlock* _owner;
+  dbBlock* owner_;
 };
 
 }  // namespace odb

src/odb/include/odb/dbBlockSet.h

@@ -17,19 +17,6 @@ class dbBlock;
 template <>
 class dbSetIterator<dbBlock>
 {
-  friend class dbSet<dbBlock>;
-
-  dbIterator* _itr;
-  uint _cur;
-  dbObject* _parent;
-
-  dbSetIterator(dbIterator* itr, uint id, dbObject* parent)
-  {
-    _itr = itr;
-    _cur = id;
-    _parent = parent;
-  }
-
  public:
   using value_type = dbBlock*;
   using difference_type = std::ptrdiff_t;
@@ -39,87 +26,98 @@ class dbSetIterator<dbBlock>
 
   dbSetIterator()
   {
-    _itr = nullptr;
-    _cur = 0;
-    _parent = nullptr;
+    itr_ = nullptr;
+    cur_ = 0;
+    parent_ = nullptr;
   }
 
   dbSetIterator(const dbSetIterator& it)
   {
-    _itr = it._itr;
-    _cur = it._cur;
-    _parent = it._parent;
+    itr_ = it.itr_;
+    cur_ = it.cur_;
+    parent_ = it.parent_;
   }
 
   bool operator==(const dbSetIterator<dbBlock>& it)
   {
-    return (_itr == it._itr) && (_cur == it._cur) && (_parent == it._parent);
+    return (itr_ == it.itr_) && (cur_ == it.cur_) && (parent_ == it.parent_);
   }
 
   bool operator!=(const dbSetIterator<dbBlock>& it)
   {
-    return (_itr != it._itr) || (_cur != it._cur) || (_parent != it._parent);
+    return (itr_ != it.itr_) || (cur_ != it.cur_) || (parent_ != it.parent_);
   }
 
-  dbBlock* operator*() { return (dbBlock*) _itr->getObject(_cur, _parent); }
+  dbBlock* operator*() { return (dbBlock*) itr_->getObject(cur_, parent_); }
 
-  dbBlock* operator->() { return (dbBlock*) _itr->getObject(_cur, _parent); }
+  dbBlock* operator->() { return (dbBlock*) itr_->getObject(cur_, parent_); }
 
   dbSetIterator<dbBlock>& operator++()
   {
-    _cur = _itr->next(_cur);
+    cur_ = itr_->next(cur_);
     return *this;
   }
 
   dbSetIterator<dbBlock> operator++(int)
   {
     dbSetIterator it(*this);
-    _cur = _itr->next(_cur);
+    cur_ = itr_->next(cur_);
     return it;
   }
+
+ private:
+  friend class dbSet<dbBlock>;
+
+  dbSetIterator(dbIterator* itr, uint id, dbObject* parent)
+  {
+    itr_ = itr;
+    cur_ = id;
+    parent_ = parent;
+  }
+
+  dbIterator* itr_;
+  uint cur_;
+  dbObject* parent_;
 };
 
 template <>
 class dbSet<dbBlock>
 {
-  dbIterator* _itr;
-  dbObject* _parent;
-
  public:
   using iterator = dbSetIterator<dbBlock>;
 
   dbSet()
   {
-    _itr = nullptr;
-    _parent = nullptr;
+    itr_ = nullptr;
+    parent_ = nullptr;
   }
 
   dbSet(dbObject* parent, dbIterator* itr)
   {
-    _parent = parent;
-    _itr = itr;
+    parent_ = parent;
+    itr_ = itr;
   }
 
   dbSet(const dbSet<dbBlock>& c)
   {
-    _itr = c._itr;
-    _parent = c._parent;
+    itr_ = c.itr_;
+    parent_ = c.parent_;
   }
 
   ///
   /// Returns the number of items in this set.
   ///
-  uint size() { return _itr->size(_parent); }
+  uint size() { return itr_->size(parent_); }
 
   ///
   /// Return a begin() iterator.
   ///
-  iterator begin() { return iterator(_itr, _itr->begin(_parent), _parent); }
+  iterator begin() { return iterator(itr_, itr_->begin(parent_), parent_); }
 
   ///
   /// Return an end() iterator.
   ///
-  iterator end() { return iterator(_itr, _itr->end(_parent), _parent); }
+  iterator end() { return iterator(itr_, itr_->end(parent_), parent_); }
 
   ///
   /// Returns true if set is empty
@@ -130,23 +128,27 @@ class dbSet<dbBlock>
   /// Returns the maximum number sequential elements the this set
   /// may iterate.
   ///
-  uint sequential() { return _itr->sequential(); }
+  uint sequential() { return itr_->sequential(); }
 
   ///
   /// Returns true if this set is reversible.
   ///
-  bool reversible() { return _itr->reversible(); }
+  bool reversible() { return itr_->reversible(); }
 
   ///
   /// Returns true if the is iterated in the reverse order that
   /// it was created.
   ///
-  bool orderReversed() { return _itr->orderReversed(); }
+  bool orderReversed() { return itr_->orderReversed(); }
 
   ///
   /// Reverse the order of this set.
   ///
-  void reverse() { _itr->reverse(_parent); }
+  void reverse() { itr_->reverse(parent_); }
+
+ private:
+  dbIterator* itr_;
+  dbObject* parent_;
 };
 
 }  // namespace odb

src/odb/include/odb/dbCCSegSet.h

@@ -17,19 +17,6 @@ class dbCCSeg;
 template <>
 class dbSetIterator<dbCCSeg>
 {
-  friend class dbSet<dbCCSeg>;
-
-  dbIterator* _itr;
-  uint _cur;
-  uint _pid;
-
-  dbSetIterator(dbIterator* itr, uint id, uint pid)
-  {
-    _itr = itr;
-    _cur = id;
-    _pid = pid;
-  }
-
  public:
   using value_type = dbCCSeg*;
   using difference_type = std::ptrdiff_t;
@@ -39,113 +26,128 @@ class dbSetIterator<dbCCSeg>
 
   dbSetIterator()
   {
-    _itr = nullptr;
-    _cur = 0;
-    _pid = 0;
+    itr_ = nullptr;
+    cur_ = 0;
+    pid_ = 0;
   }
 
   dbSetIterator(const dbSetIterator& it)
   {
-    _itr = it._itr;
-    _cur = it._cur;
-    _pid = it._pid;
+    itr_ = it.itr_;
+    cur_ = it.cur_;
+    pid_ = it.pid_;
   }
 
   bool operator==(const dbSetIterator<dbCCSeg>& it)
   {
-    return (_itr == it._itr) && (_cur == it._cur) && (_pid == it._pid);
+    return (itr_ == it.itr_) && (cur_ == it.cur_) && (pid_ == it.pid_);
   }
 
   bool operator!=(const dbSetIterator<dbCCSeg>& it)
   {
-    return (_itr != it._itr) || (_cur != it._cur) || (_pid != it._pid);
+    return (itr_ != it.itr_) || (cur_ != it.cur_) || (pid_ != it.pid_);
   }
 
-  dbCCSeg* operator*() { return (dbCCSeg*) _itr->getObject(_cur); }
+  dbCCSeg* operator*() { return (dbCCSeg*) itr_->getObject(cur_); }
 
-  dbCCSeg* operator->() { return (dbCCSeg*) _itr->getObject(_cur); }
+  dbCCSeg* operator->() { return (dbCCSeg*) itr_->getObject(cur_); }
 
   dbSetIterator<dbCCSeg>& operator++()
   {
-    _cur = _itr->next(_cur, _pid);
+    cur_ = itr_->next(cur_, pid_);
     return *this;
   }
 
   dbSetIterator<dbCCSeg> operator++(int)
   {
     dbSetIterator it(*this);
-    _cur = _itr->next(_cur, _pid);
+    cur_ = itr_->next(cur_, pid_);
     return it;
   }
+
+ private:
+  friend class dbSet<dbCCSeg>;
+
+  dbSetIterator(dbIterator* itr, uint id, uint pid)
+  {
+    itr_ = itr;
+    cur_ = id;
+    pid_ = pid;
+  }
+
+  dbIterator* itr_;
+  uint cur_;
+  uint pid_;
 };
 
 template <>
 class dbSet<dbCCSeg>
 {
-  dbIterator* _itr;
-  dbObject* _parent;
-  uint _pid;
-
  public:
   using iterator = dbSetIterator<dbCCSeg>;
 
   dbSet()
   {
-    _itr = nullptr;
-    _parent = nullptr;
-    _pid = 0;
+    itr_ = nullptr;
+    parent_ = nullptr;
+    pid_ = 0;
   }
 
   dbSet(dbObject* parent, dbIterator* itr)
   {
-    _parent = parent;
-    _itr = itr;
-    _pid = parent->getId();
+    parent_ = parent;
+    itr_ = itr;
+    pid_ = parent->getId();
   }
 
   dbSet(const dbSet<dbCCSeg>& c)
   {
-    _itr = c._itr;
-    _parent = c._parent;
-    _pid = c._pid;
+    itr_ = c.itr_;
+    parent_ = c.parent_;
+    pid_ = c.pid_;
   }
 
   ///
   /// Returns the number of items in this set.
   ///
-  uint size() { return _itr->size(_parent); }
+  uint size() { return itr_->size(parent_); }
 
   ///
   /// Return a begin() iterator.
   ///
-  iterator begin() { return iterator(_itr, _itr->begin(_parent), _pid); }
+  iterator begin() { return iterator(itr_, itr_->begin(parent_), pid_); }
 
   ///
   /// Return an end() iterator.
   ///
-  iterator end() { return iterator(_itr, _itr->end(_parent), _pid); }
+  iterator end() { return iterator(itr_, itr_->end(parent_), pid_); }
 
   ///
   /// Returns the maximum number sequential elements the this set
   /// may iterate.
   ///
-  uint sequential() { return _itr->sequential(); }
+  uint sequential() { return itr_->sequential(); }
 
   ///
   /// Returns true if this set is reversible.
   ///
-  bool reversible() { return _itr->reversible(); }
+  bool reversible() { return itr_->reversible(); }
 
   ///
   /// Returns true if the is iterated in the reverse order that
   /// it was created.
   ///
-  bool orderReversed() { return _itr->orderReversed(); }
+  bool orderReversed() { return itr_->orderReversed(); }
 
   ///
   /// Reverse the order of this set.
   ///
-  void reverse() { _itr->reverse(_parent); }
+  void reverse() { itr_->reverse(parent_); }
+
+ private:
+  dbIterator* itr_;
+  dbObject* parent_;
+  uint pid_;
 };
 
 }  // namespace odb