Merge pull request #8924 from The-OpenROAD-Project-staging/odb-refactor3

Odb refactor3

Author: maliberty

src/odb/include/odb/ZException.h

@@ -3,28 +3,26 @@
 
 #pragma once
 
-#include <iterator>
-
 #include "odb/odb.h"
 
 namespace odb {
 
 class dbObject;
-class dbObjectTable;
 
 class dbIterator
 {
  public:
-  virtual bool reversible() = 0;
-  virtual bool orderReversed() = 0;
+  virtual ~dbIterator() = default;
+
+  virtual bool reversible() const = 0;
+  virtual bool orderReversed() const = 0;
   virtual void reverse(dbObject* parent) = 0;
-  virtual uint sequential() = 0;
-  virtual uint size(dbObject* parent) = 0;
-  virtual uint begin(dbObject* parent) = 0;
-  virtual uint end(dbObject* parent) = 0;
-  virtual uint next(uint id, ...) = 0;
+  virtual uint sequential() const = 0;
+  virtual uint size(dbObject* parent) const = 0;
+  virtual uint begin(dbObject* parent) const = 0;
+  virtual uint end(dbObject* parent) const = 0;
+  virtual uint next(uint id, ...) const = 0;
   virtual dbObject* getObject(uint id, ...) = 0;
-  virtual ~dbIterator() = default;
 };
 
 }  // namespace odb

src/odb/include/odb/dbIterator.h

@@ -3,10 +3,10 @@
 
 #pragma once
 
+#include <cassert>
 #include <map>
 #include <vector>
 
-#include "odb/ZException.h"
 #include "odb/dbMap.h"
 #include "odb/dbSet.h"
 
@@ -48,12 +48,12 @@ inline const D& dbMap<T, D>::operator[](T* object) const
 {
   if (_map) {
     typename std::map<T*, D>::const_iterator itr = _map->find(object);
-    ZASSERT(itr != _map->end());
+    assert(itr != _map->end());
     return (*itr).second;
   }
 
   uint idx = object->getId();
-  ZASSERT(idx && (idx < _vector->size()));
+  assert(idx && (idx < _vector->size()));
   return (*_vector)[idx];
 }
 
@@ -65,7 +65,7 @@ inline D& dbMap<T, D>::operator[](T* object)
   }
 
   uint idx = object->getId();
-  ZASSERT(idx && (idx < _vector->size()));
+  assert(idx && (idx < _vector->size()));
   return (*_vector)[idx];
 }
 

src/odb/include/odb/dbMap.hpp

@@ -7,6 +7,7 @@
 #include <iterator>
 
 #include "odb/dbIterator.h"
+#include "odb/odb.h"
 
 namespace odb {
 
@@ -20,30 +21,31 @@ class dbSet;
 template <class T>
 class dbSetIterator
 {
-  friend class dbSet<T>;
-
-  dbIterator* _itr;
-  uint _cur;
-
-  dbSetIterator(dbIterator* itr, uint id);
-
  public:
   using value_type = T*;
   using difference_type = std::ptrdiff_t;
   using pointer = T**;
   using reference = T*&;
   using iterator_category = std::input_iterator_tag;
 
-  dbSetIterator();
+  dbSetIterator() = default;
   dbSetIterator(const dbSetIterator& it) = default;
 
-  bool operator==(const dbSetIterator<T>& it);
-  bool operator!=(const dbSetIterator<T>& it);
+  bool operator==(const dbSetIterator<T>& it) const;
+  bool operator!=(const dbSetIterator<T>& it) const;
 
   T* operator*();
   T* operator->();
   dbSetIterator<T>& operator++();
   dbSetIterator<T> operator++(int);
+
+ private:
+  dbSetIterator(dbIterator* itr, uint id);
+
+  dbIterator* itr_{nullptr};
+  uint cur_{0};
+
+  friend class dbSet<T>;
 };
 
 ///
@@ -71,44 +73,33 @@ class dbSetIterator
 template <class T>
 class dbSet
 {
-  dbIterator* _itr;
-  dbObject* _parent;
-
  public:
   using iterator = dbSetIterator<T>;
 
-  dbSet()
-  {
-    _itr = nullptr;
-    _parent = nullptr;
-  }
+  dbSet() = default;
 
   dbSet(dbObject* parent, dbIterator* itr)
   {
-    _parent = parent;
-    _itr = itr;
+    parent_ = parent;
+    itr_ = itr;
   }
 
-  dbSet(const dbSet<T>& c)
-  {
-    _itr = c._itr;
-    _parent = c._parent;
-  }
+  dbSet(const dbSet<T>& c) = default;
 
   ///
   /// Returns the number of items in this set.
   ///
-  uint size() { return _itr->size(_parent); }
+  uint size() const { return itr_->size(parent_); }
 
   ///
   /// Return a begin() iterator.
   ///
-  iterator begin() { return iterator(_itr, _itr->begin(_parent)); }
+  iterator begin() const { return iterator(itr_, itr_->begin(parent_)); }
 
   ///
   /// Return an end() iterator.
   ///
-  iterator end() { return iterator(_itr, _itr->end(_parent)); }
+  iterator end() const { return iterator(itr_, itr_->end(parent_)); }
 
   ///
   /// If this set is sequential, this function will return the database
@@ -119,80 +110,77 @@ class dbSet
   ///
   /// If this set is non-sequential then it returns 0.
   ///
-  uint sequential() { return _itr->sequential(); }
+  uint sequential() const { return itr_->sequential(); }
 
   ///
   /// Returns true if this set is reversible.
   ///
-  bool reversible() { return _itr->reversible(); }
+  bool reversible() const { return itr_->reversible(); }
 
   ///
   /// Returns true if the is iterated in the reverse order that
   /// it was created.
   ///
-  bool orderReversed() { return _itr->orderReversed(); }
+  bool orderReversed() const { return itr_->orderReversed(); }
 
   ///
   /// Reverse the order of this set.
   ///
-  void reverse() { _itr->reverse(_parent); }
+  void reverse() { itr_->reverse(parent_); }
 
   ///
   /// Returns true if set is empty
   ///
-  bool empty() { return begin() == end(); }
-};
+  bool empty() const { return begin() == end(); }
 
-template <class T>
-inline dbSetIterator<T>::dbSetIterator()
-{
-  _itr = nullptr;
-  _cur = 0;
-}
+ private:
+  dbIterator* itr_{nullptr};
+  dbObject* parent_{nullptr};
+};
 
 template <class T>
 inline dbSetIterator<T>::dbSetIterator(dbIterator* itr, uint id)
 {
-  _itr = itr;
-  _cur = id;
+  itr_ = itr;
+  cur_ = id;
 }
 
 template <class T>
-inline bool dbSetIterator<T>::operator==(const dbSetIterator& it)
+inline bool dbSetIterator<T>::operator==(const dbSetIterator& it) const
 {
-  return (_itr == it._itr) && (_cur == it._cur);
+  return (itr_ == it.itr_) && (cur_ == it.cur_);
 }
 
 template <class T>
-inline bool dbSetIterator<T>::operator!=(const dbSetIterator& it)
+inline bool dbSetIterator<T>::operator!=(const dbSetIterator& it) const
 {
-  return (_itr != it._itr) || (_cur != it._cur);
+  return !(*this == it);
 }
 
 template <class T>
 inline T* dbSetIterator<T>::operator*()
 {
-  return (T*) _itr->getObject(_cur);
+  return (T*) itr_->getObject(cur_);
 }
 
 template <class T>
 inline T* dbSetIterator<T>::operator->()
 {
-  return (T*) _itr->getObject(_cur);
+  return (T*) itr_->getObject(cur_);
 }
 
 template <class T>
 inline dbSetIterator<T>& dbSetIterator<T>::operator++()
 {
-  _cur = _itr->next(_cur);
+  cur_ = itr_->next(cur_);
   return *this;
 }
 
 template <class T>
 inline dbSetIterator<T> dbSetIterator<T>::operator++(int)
 {
   dbSetIterator it(*this);
-  _cur = _itr->next(_cur);
+  cur_ = itr_->next(cur_);
   return it;
 }
 

src/odb/include/odb/dbSet.h

@@ -7,7 +7,6 @@
 #include <cmath>
 #include <vector>
 
-#include "odb/ZException.h"
 #include "odb/dbObject.h"
 #include "odb/dbSet.h"
 #include "odb/dbTransform.h"

src/odb/include/odb/dbShape.h

@@ -20,7 +20,6 @@
 #include <vector>
 
 #include "boost/container/flat_map.hpp"
-#include "odb/ZException.h"
 #include "odb/dbObject.h"
 #include "odb/odb.h"