add odb, which is from OpenROAD

CMakeLists.txt

@@ -55,6 +55,7 @@ message(STATUS "Install prefix: ${CMAKE_INSTALL_PREFIX}")
 include_directories(
   ${CMAKE_SOURCE_DIR}/include
   ${CMAKE_SOURCE_DIR}/pkgs
+  ${CMAKE_SOURCE_DIR}/pkgs/include
   ${CMAKE_SOURCE_DIR}/pkgs/boost_1_78_0
 )
 

src/CMakeLists.txt

@@ -88,4 +88,5 @@ add_compile_options(
 
 add_subdirectory(main)
 add_subdirectory(utl)
+add_subdirectory(odb)
 

src/main/CMakeLists.txt

@@ -4,7 +4,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/src/cmake")
 include("swig_lib")
 
 # paths for submodule
-set(ODB_HOME ${PROJECT_SOURCE_DIR}/src/odb)
+set(odb_HOME ${PROJECT_SOURCE_DIR}/src/odb)
 
 # main program source
 set(MINIEDA_SOURCE
@@ -22,6 +22,7 @@ swig_lib(NAME      minieda_swig
 target_link_libraries(minieda_swig
   PRIVATE
     utl
+    odb
 )
 
 add_executable(minieda
@@ -52,6 +53,7 @@ target_include_directories(minieda
 target_link_libraries(minieda
   minieda_swig
   utl
+  odb
   ${CMAKE_THREAD_LIBS_INIT}
   ${TCL_LIBRARY}
 )

src/odb/.gitignore

+# python cache
+__pycache__/
+*.py[cod]
+
+*~
+core
+*.core
+TAGS
+defRWarning.log
+
+test/results

src/odb/CMakeLists.txt

+############################################################################
+########################### Project Setup ##################################
+############################################################################
+
+# Setting CMake version properly to ensure correct policies behavior
+cmake_minimum_required(VERSION 3.14...3.16)
+# Setting up OpenDB project
+project(odb VERSION 0.0.1
+  LANGUAGES CXX)
+
+# Configure build version
+configure_file (
+    "${PROJECT_SOURCE_DIR}/include/odb/version.hh.in"
+    "${PROJECT_BINARY_DIR}/include/odb/version.hh"
+)
+
+############################################################################
+################################# Targets ##################################
+############################################################################
+
+add_subdirectory(src/db)
+add_subdirectory(src/defin)
+add_subdirectory(src/defout)
+add_subdirectory(src/lef)
+add_subdirectory(src/lefin)
+add_subdirectory(src/lefout)
+add_subdirectory(src/def)
+add_subdirectory(src/zutil)
+add_subdirectory(src/tm)
+add_subdirectory(src/cdl)
+# add_subdirectory(src/upf)
+add_subdirectory(test/cpp)
+
+add_library(odb INTERFACE)
+target_link_libraries(odb
+  INTERFACE
+    db
+    cdl
+    defin
+    defout
+    lefin
+    lefout
+    tm
+    zutil
+    utl
+    ${TCL_LIBRARY}
+)
+
+############################################################################
+################################# SWIG #####################################
+############################################################################
+
+include(${SWIG_USE_FILE})
+
+add_subdirectory(src/swig/common)
+# if (Python3_FOUND AND BUILD_PYTHON)
+#   add_subdirectory(src/swig/python)
+# endif()
+add_subdirectory(src/swig/tcl)
+
+############################################################################
+############################### DOXYGEN ####################################
+############################################################################
+find_package(Doxygen)
+
+if (DOXYGEN_FOUND)
+  set(DOXYGEN_EXTRACT_STATIC YES)
+  set(DOXYGEN_REFERENCED_BY_RELATION YES)
+  set(DOXYGEN_REFERENCES_RELATION YES)
+
+  doxygen_add_docs(docs include)
+endif()

src/odb/Dockerfile

+FROM centos:centos7 AS base-dependencies
+LABEL maintainer="Abdelrahman Hosny <abdelrahman_hosny@brown.edu>"
+
+# Install dev and runtime dependencies
+RUN yum group install -y "Development Tools" \
+    && yum install -y https://repo.ius.io/ius-release-el7.rpm \
+    && yum install -y centos-release-scl \
+    && yum install -y wget devtoolset-8 \
+    devtoolset-8-libatomic-devel tcl-devel tcl tk libstdc++ tk-devel pcre-devel \
+    python36u python36u-libs python36u-devel python36u-pip && \
+    yum clean -y all && \
+    rm -rf /var/lib/apt/lists/*
+
+ENV CC=/opt/rh/devtoolset-8/root/usr/bin/gcc \
+    CPP=/opt/rh/devtoolset-8/root/usr/bin/cpp \
+    CXX=/opt/rh/devtoolset-8/root/usr/bin/g++ \
+    PATH=/opt/rh/devtoolset-8/root/usr/bin:$PATH \
+    LD_LIBRARY_PATH=/opt/rh/devtoolset-8/root/usr/lib64:/opt/rh/devtoolset-8/root/usr/lib:/opt/rh/devtoolset-8/root/usr/lib64/dyninst:/opt/rh/devtoolset-8/root/usr/lib/dyninst:/opt/rh/devtoolset-8/root/usr/lib64:/opt/rh/devtoolset-8/root/usr/lib:$LD_LIBRARY_PATH
+
+# Install CMake
+RUN wget https://cmake.org/files/v3.14/cmake-3.14.0-Linux-x86_64.sh && \
+    chmod +x cmake-3.14.0-Linux-x86_64.sh  && \
+    ./cmake-3.14.0-Linux-x86_64.sh --skip-license --prefix=/usr/local && rm -rf cmake-3.14.0-Linux-x86_64.sh \
+    && yum clean -y all
+
+# Install epel repo
+RUN wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm && \
+    yum install -y epel-release-latest-7.noarch.rpm && rm -rf epel-release-latest-7.noarch.rpm  \
+    && yum clean -y all
+
+# Install any git version > 2.6.5
+RUN yum remove -y git* && yum install -y git224
+
+# Install SWIG
+RUN yum remove -y swig \
+    && wget https://github.com/swig/swig/archive/rel-4.0.1.tar.gz \
+    && tar xfz rel-4.0.1.tar.gz \
+    && rm -rf rel-4.0.1.tar.gz \
+    && cd swig-rel-4.0.1 \
+    && ./autogen.sh && ./configure --prefix=/usr && make -j $(nproc) && make install \
+    && cd .. \
+    && rm -rf swig-rel-4.0.1
+
+# boost
+RUN wget https://sourceforge.net/projects/boost/files/boost/1.72.0/boost_1_72_0.tar.bz2/download && \
+    tar -xf download && \
+    cd boost_1_72_0 && \
+    ./bootstrap.sh && \
+    ./b2 install --with-iostreams --with-test -j $(nproc)
+    
+RUN pip3 install testtools
+
+# spdlog for logging
+RUN git clone -b v1.8.1 https://github.com/gabime/spdlog.git \
+    && cd spdlog \
+    && mkdir build \
+    && cd build \
+    && cmake .. \
+    && make install -j
+    
+FROM base-dependencies AS builder
+
+
+COPY . /OpenDB
+WORKDIR /OpenDB
+
+# Build
+RUN mkdir build
+RUN cd build && cmake .. && make -j 4

src/odb/LICENSE

+BSD 3-Clause License
+
+Copyright (c) 2019, Nefelus Inc
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

src/odb/README.md

+# OpenDB
+
+OpenDB is a design database to support tools for physical chip design. It
+was originally developed by Athena Design Systems. Nefelus, Inc. acquired
+the rights to the code and open-sourced it with BSD-3 license in 2019 to support the DARPA
+OpenROAD project.
+
+The structure of OpenDB is based on the text file formats LEF
+(library) and DEF (design) formats version 5.6.  OpenDB supports a
+binary file format to save and load the design much faster than using
+LEF and DEF.
+
+OpenDB is written in C++ 98 with standard library style iterators.
+The classes are designed to be fast enough to base an application on without
+having to copy them into application-specific structures.
+
+
+## Directory structure
+
+```
+include/odb/db.h - public header for all database classes
+src/db - private/internal database representations
+src/lefin - LEF reader
+src/lefout - LEF writer
+src/defin - DEF reader
+src/defout - DEF writer
+```
+
+## Database API
+
+We are still working on documenting the APIs.  We have over 1,800 objects
+and functions that we are still documenting (for both TCL and Python).
+**Contributions are very welcome in this effort**. Find starting points below.
+
+### TCL
+
+After building successfully, run OpenDB Tcl shell using
+`../../build/src/odb/src/swig/tcl/odbtcl`. An example usage:
+
+```
+set db [dbDatabase_create]
+set lef_parser [new_lefin $db true]
+set tech [lefin_createTech $lef_parser ./src/odb/test/data/gscl45nm.lef]
+```
+
+You can find examples on using the API from Tcl under `test/tcl/` directory.
+
+The full set of the Tcl commands exposed can be found under
+`./build/src/swig/tcl/opendb_wrapper.cpp`. Search for `SWIG_prefix`.
+
+
+### Python
+
+After building successfully, run `openroad -python` to enable the Python
+interpreter. You can find examples on using the API from Python under
+`test/python/` directory.
+
+To list the full set of the Python classes exposed run `openroad -python`
+then:
+```
+import openroad
+import odb
+print(', '.join(dir(openroad)))
+print(', '.join(dir(odb)))
+```
+
+### C++
+
+All public database classes are defined in `db.h`. These class definitions
+provide all functions for examining and modifying the database objects. The
+database is an object itself, so multiple database objects can exist
+simultaneously (no global state).
+
+`dbTypes.h` defines types returned by database class member functions.
+
+All database objects are in the `odb` namespace.
+
+-   `dbChip`
+-   `dbBlock`
+-   `dbTech`
+-   `dbLib`
+
+All database objects have a 32bit object identifier accessed with the
+`dbObject::getOID` base class member function that returns a `uint`. This
+identifier is preserved across save/restores of the database so it should
+be used to reference database object by data structures instead of pointers
+if the reference lifetime is across database save/restores. OIDs allow the
+database to have exactly the same layout across save/restores.
+
+The database distance units are **nanometers** and use the type `uint`.
+
+## Example scripts
+
+## Regression tests
+
+There are a set of regression tests in /test.
+
+```
+./test/regression-tcl.sh
+./test/regression-py.sh
+```
+
+## Database Internals
+
+The internal description included here is paraphrased from Lukas van Ginneken
+by James Cherry.
+
+The database separates the implementation from the interface, and as a result,
+each class becomes two classes, a public one and a private one. For instance,
+`dbInst` has the public API functions, while class `_dbInst` has the private
+data fields.
+
+The objects are allocated in dynamically resizable tables, the implementation
+of which is in `dbTable.hpp`. Each table consists of a number of pages,
+each containing 128 objects. The table contains the body of the `struct`,
+not a set of pointers. This eliminates most of the pointer overhead while
+iteration is accomplished by stepping through the table. Thus, grouping these
+objects does not require a doubly-linked list and saves 16 bytes per object
+(at the cost of some table overhead). Each object has an id, which is the
+index into the table. The lowest 7 bits are the index in the page, while
+the higher bits are the page number. Object id's are persistent when saving
+and reading the data model to disk, even as pointer addresses may change.
+
+Everything in the data model can be stored on disk and restored from disk
+exactly the way it was. An extensive set of equality tests and diff functions
+make it possible to check for even the smallest deviation. The capability
+to save an exact copy of the state of the system makes it possible to create
+a checkpoint. This is a necessary capability for debugging complex systems.
+
+The code follows the definition of LEF and DEF closely and reflects many of
+the idiosyncrasies of LEF and DEF. The code defines many types of objects
+to reflect LEF and DEF constructs although it sometimes uses different
+terminology, for instance, the object to represent a library cell is called
+`dbMaster` while the LEF keyword is MACRO.
+
+The data model supports the EEQ and LEQ keywords (i.e., electrically equivalent
+and logically equivalent Masters), which could be useful for sizing. However,
+it does not support any logic function representation. In general, there is
+very limited support for synthesis-specific information: no way to represent
+busses, no way to represent logic function, very limited understanding of
+signal flow, limited support of timing information, and no support for high
+level synthesis or test insertion.
+
+The db represents routing as in DEF, representing a trace from point to point
+with a given width. The layout for a net is stored in a class named `dbWire`
+and it requires a special `dbWireDecoder` (which works like an iterator)
+to unpack the data and another `dbWireEncoder` to pack it. The data model
+does not support a region query and objects that are in the same layer are
+scattered about the data model and are of different classes.
+
+This means that whatever tool is using the layout information will have to
+build its own data structures that are suitable to the layout operations
+of that tool. For instance, the router, the extractor, and the DRC engine
+would each have to build their unique data structures. This encourages
+batch mode operation (route the whole chip, extract the whole chip, run
+DRC on the whole chip).
+
+## Limitations
+
+## FAQs
+
+Check out
+[GitHub discussion](https://github.com/The-OpenROAD-Project/OpenROAD/discussions/categories/q-a?discussions_q=category%3AQ%26A+fastroute+in%3Atitle)
+about this tool.
+
+
+## LICENSE
+
+BSD 3-Clause License. See [LICENSE](LICENSE) file.

src/odb/doc/OpenDB-AddFieldsInDbObjects.md

+# Adding new fields in DB Object
+
+For example `add_pitchDiag` in object `DbTechLayer`.
+
+|   | Action                                                 | File              | Source Code                                                                        |
+|---|--------------------------------------------------------|-------------------|------------------------------------------------------------------------------------|
+| 1 | Add Fields at the .h file                              | `dbTechLayer.h`   |                                                                                    |
+| 2 | Define a keyword for db rev number                     | `dbDatabase.h`    | `#define ADS_DB_DF58 52`                                                           |
+| 3 | Set the current rev number same as                     | `dbDatabase.h`    | `#define ADS_DB_SCHEMA_MINOR 52`                                                   |
+| 4 | Stream in new fields Conditionally upon Schema number  | `dbTechLayer.cpp` | `if ( stream.getDatabase()->isSchema(ADS_DB_DF58) ) { stream >> layer._pitchDiag;` |
+| 5 | Stream out new fields Conditionally upon Schema number | `dbTechLayer.cpp` | `if ( stream.getDatabase()->isSchema(ADS_DB_DF58) ) { stream << layer._pitchDiag;` |
+| 6 | Conditionally Diff new fields                          | `dbTechLayer.cpp` | `if ( stream.getDatabase()->isSchema(ADS_DB_DF58) ) { DIFF_FIELD(_pitchDiag);`     |
+| 7 | Conditionally Diff Out new fields                      | `dbTechLayer.cpp` | `if ( stream.getDatabase()->isSchema(ADS_DB_DF58) ) { DIFF_OUT_FIELD(_pitchDiag);` |
+| 8 | Created access APIs to the fields                      | `dbTechLayer.cpp` | `"dbTechLayer::getPitchDiag(), dbTechLayer::setPitchDiag( int pitch )"`            |
+| 9 | Add new APIs in include/db.h                           | db.h              | `class dbTechLayer`                                                                |

src/odb/include/odb/ISdb.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "IZdcr.h"
+#include "ZInterface.h"
+#include "ZObject.h"
+#include "array1.h"
+#include "geom.h"
+#include "gseq.h"
+#include "odb.h"
+#include "util.h"
+#include "rcx.h"
+
+namespace odb {
+
+class Ath__gridTable;
+class dbBox;
+class dbBlock;
+class dbTech;
+class dbNet;
+
+///
+/// ISdb - Internal User Interface for ZRoute Area Search Infrastructure
+///
+///
+
+class ISdb : public ZObject
+{
+ public:
+  ZINTERFACE_ID(ISdb);
+
+  virtual void removeMarkedNetWires() = 0;
+  virtual void reMakeSdb(dbTech* tech, dbBlock* block) = 0;
+  virtual void cleanSdb() = 0;
+  virtual void dumpTrackCounts(FILE* fp) = 0;
+  virtual void setExtControl(dbBlock* block,
+                             bool useDbSdb,
+                             uint adj,
+                             uint npsrc,
+                             uint nptgt,
+                             uint ccUp,
+                             bool allNet,
+                             uint contextDepth,
+                             Ath__array1D<int>** contextArray,
+                             uint* contextLength,
+                             Ath__array1D<SEQ*>*** dgContextArray,
+                             uint* dgContextDepth,
+                             uint* dgContextPlanes,
+                             uint* dgContextTracks,
+                             uint* dgContextBaseLvl,
+                             int* dgContextLowLvl,
+                             int* dgContextHiLvl,
+                             uint* dgContextBaseTrack,
+                             int* dgContextLowTrack,
+                             int* dgContextHiTrack,
+                             int** dgContextTrackBase,
+                             AthPool<SEQ>* seqPool)
+      = 0;
+  virtual void adjustOverlapMakerEnd() = 0;
+  virtual void adjustMetalFill() = 0;
+  virtual void setupForBoxes(Rect maxRect, uint minHeight, uint minWidth) = 0;
+  virtual void addBox(dbBox* bb, uint wtype, uint id) = 0;
+  virtual uint setExtrusionMarker(uint startRow, uint startCol) = 0;
+  virtual Ath__gridTable* getSearchPtr() = 0;
+  virtual void setDefaultWireType(uint v) = 0;
+
+  virtual uint addBox(int x1,
+                      int y1,
+                      int x2,
+                      int y2,
+                      uint level,
+                      uint id1,
+                      uint id2,
+                      uint wtype)
+      = 0;
+  virtual void getBox(uint wid,
+                      int* x1,
+                      int* y1,
+                      int* x2,
+                      int* y2,
+                      uint* level,
+                      uint* id1,
+                      uint* id2,
+                      uint* wtype)
+      = 0;
+
+  virtual uint addBlockages(dbBlock* block) = 0;
+  virtual void initSearchForNets(dbTech* tech, dbBlock* block) = 0;
+  virtual uint addNetSBoxes(dbNet* net, uint wtype, bool skipVias) = 0;
+  virtual void addPowerNets(dbBlock* block, uint wtype, bool skipVias) = 0;
+  virtual void addSignalNets(dbBlock* block, uint wtype, uint vtype) = 0;
+  virtual void addSignalNets(dbBlock* block, uint wtype, bool wireVia) = 0;
+  virtual void searchWireIds(int x1,
+                             int y1,
+                             int x2,
+                             int y2,
+                             bool ignoreLayers,
+                             bool* exludeTable)
+      = 0;
+  virtual void searchBoxIds(int x1, int y1, int x2, int y2) = 0;
+
+  virtual void setMaxArea(int x1, int y1, int x2, int y2) = 0;
+  virtual void resetMaxArea() = 0;
+
+  virtual uint couplingCaps(ZPtr<ISdb> ccSdb,
+                            uint couplingDist,
+                            ZInterface* Interface,
+                            rcx::CoupleAndCompute coupleAndCompute,
+                            void* compPtr)
+      = 0;
+  virtual uint startIterator() = 0;
+  virtual uint getNextWireId() = 0;
+  virtual bool getNextBox(int& x1,
+                          int& y1,
+                          int& x2,
+                          int& y2,
+                          uint& level,
+                          uint& netId,
+                          uint& shapeId)
+      = 0;
+  virtual void getCCdist(uint wid,
+                         uint* width,
+                         uint* level,
+                         uint* id1,
+                         uint* id2)
+      = 0;
+  virtual void getIds(uint wid, uint* id1, uint* id2, uint* wtype) = 0;
+};
+}  // namespace odb

src/odb/include/odb/IZdcr.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "ZObject.h"
+#include "geom.h"
+#include "odb.h"
+
+namespace odb {
+
+///
+/// IZdcr
+///
+///
+
+class IZdcr : public ZObject
+{
+ public:
+  ZINTERFACE_ID(IZdcr);
+
+  virtual uint getAppGuiCnt() = 0;
+
+  virtual void chip_get(const char* chip,
+                        bool gridFlag,
+                        int maxobjects,
+                        FILE* outFP)
+      = 0;
+  virtual void chipAttr(char* layers, uint n, bool def) = 0;
+
+  virtual void init(ZContext& context,
+                    bool dbEnv,
+                    const char* name,
+                    const char* module,
+                    bool noStore)
+      = 0;
+  virtual char* setName(const char* name) = 0;
+  virtual char* getName() = 0;
+  //	virtual Ath__zui *getZui()=0;
+  virtual void setBlockId(uint v) = 0;
+  virtual uint getBlockId() = 0;
+  virtual bool isBlockSelected(uint bid) = 0;
+
+  virtual char* getInspectName() = 0;
+
+  virtual uint addSubMenu(uint menuId, const char* name, uint boxId) = 0;
+  virtual uint getMenuId(const char* name) = 0;
+  virtual uint initDbMenus() = 0;
+  virtual uint setupModuleMenu(const char* moduleName,
+                               const char* onechar,
+                               uint id)
+      = 0;
+  virtual void getChipAttr(char* bbox,
+                           char* layers,
+                           char* menus,
+                           char* blocks,
+                           char* defTypes)
+      = 0;
+  virtual uint getMenuNames(char* buff) = 0;
+  virtual void writeToTcl(uint lineLimit, FILE* fp, bool w2l) = 0;
+  virtual uint setInspectEnv(const char* action,
+                             const char* objectName,
+                             const char* bb,
+                             const char* selectType,
+                             bool noclip)
+      = 0;
+  virtual void setFilters(const char* chip,
+                          const char* layer,
+                          const char* type,
+                          const char* hier)
+      = 0;
+  virtual bool getPullDownMenu(const char* objectName) = 0;
+  virtual uint getSubmenuObjId(uint* id2) = 0;
+  virtual uint getPullDownActionId() = 0;
+  virtual bool msgAction() = 0;
+  virtual bool selectAction() = 0;
+  virtual bool isSelectedMenu(const char* name) = 0;
+  virtual uint getSelectIds(uint* id1, uint* id2, uint* id3) = 0;
+  virtual bool isSubmenuType(uint id) = 0;
+  virtual char* getMsgBuffer(bool setBuffFlag) = 0;
+  virtual void print_self(char* blk, char* name, char* extra) = 0;
+  virtual void wireMsg(int x1,
+                       int y1,
+                       int x2,
+                       int y2,
+                       uint level,
+                       char* msg_buf)
+      = 0;
+
+  virtual void getBbox(int* x1, int* y1, int* x2, int* y2) = 0;
+  virtual char* getFirstTclBox(int* x1, int* y1, int* x2, int* y2, uint* layer)
+      = 0;
+
+  virtual void resetSearchParams(char* chip,
+                                 const char* bb,
+                                 const char* layer,
+                                 const char* hier,
+                                 const char* type,
+                                 bool noclip,
+                                 bool q)
+      = 0;
+
+  virtual int getCoords(const char* bb, int* x1, int* y1, int* x2, int* y2) = 0;
+
+  virtual uint addBox(uint id,
+                      uint subMenuId,
+                      uint menuId,
+                      int layer,
+                      int x1,
+                      int y1,
+                      int x2,
+                      int y2,
+                      uint ownId,
+                      const char* boxType = NULL)
+      = 0;
+  virtual uint addArrow(bool right,
+                        uint boxType,
+                        uint hier,
+                        int layer,
+                        int labelCnt,
+                        char** label,
+                        double* val,
+                        int x1,
+                        int y1,
+                        int x2,
+                        int y2,
+                        uint boxFilter)
+      = 0;
+  virtual uint addBoxAndMsg(uint id,
+                            uint subMenuId,
+                            uint menuId,
+                            int layer,
+                            int x1,
+                            int y1,
+                            int x2,
+                            int y2,
+                            uint ownId,
+                            const char* special)
+      = 0;
+
+  virtual bool* getExcludeLayerTable() = 0;
+  virtual bool getSubMenuFlag(uint menuId, uint subMenuId) = 0;
+  virtual uint addPullDownMenu(uint menuId,
+                               uint subMenuId,
+                               const char* db_name,
+                               const char* zui_action)
+      = 0;
+  virtual uint addPullDownMenu(const char* menu,
+                               const char* subMenu,
+                               const char* db_name,
+                               const char* zui_action)
+      = 0;
+  virtual bool validSearchBbox() = 0;
+  virtual void setSearchBox(int x1, int y1, int x2, int y2) = 0;
+  virtual bool clipBox(int& x1, int& y1, int& x2, int& y2) = 0;
+  virtual bool invalidateSearchBox() = 0;
+  virtual bool isInspectMenu(uint menuId) = 0;
+  virtual bool isInspectSubMenu(uint subMenuId) = 0;
+  virtual bool isInspectSubMenu(uint menuId, uint subMenuId) = 0;
+
+  virtual void setContextMarker() = 0;
+  virtual void setSignalMarker() = 0;
+  virtual void setInstMarker() = 0;
+  virtual void resetMarker() = 0;
+
+  virtual void* getDpt() = 0;
+  virtual uint writeToDpt() = 0;
+};
+
+}  // namespace odb

src/odb/include/odb/ZComponents.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "odb.h"
+
+///
+/// ZINTERFACE - Declare the interface identifier; add to adsInterfaces enum
+/// in ZComponents.h
+///
+#define ZINTERFACE(INTERFACE) ZIID_##INTERFACE
+
+///
+/// ZCOMPONENT - Declare the component identifier; add to adsComponents enum
+/// in ZComponents.h
+///
+#define ZCOMPONENT(COMPONENT) ZCID_##COMPONENT
+
+namespace odb {
+
+enum ZComponentID
+{
+  ZCOMPONENT(Sdb),
+  ZCOMPONENT(Zdcr),
+};
+
+enum ZInterfaceID
+{
+  ZIID_ZObject = 0,
+
+  // Place all entries after this line
+  ZINTERFACE(ISdb),
+  ZINTERFACE(IZdcr),
+};
+
+}  // namespace odb

src/odb/include/odb/ZException.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <stdarg.h>
+#include <stdexcept>
+
+#include "odb.h"
+
+#ifdef __GNUC__
+#define ADS_FORMAT_PRINTF(F, A) __attribute__((format(printf, F, A)))
+#else
+#define ADS_FORMAT_PRINTF(F, A)
+#endif
+
+namespace odb {
+
+inline
+std::runtime_error ZException(const char* fmt, ...) // ADS_FORMAT_PRINTF(2, 3)
+{
+  char buffer[8192];
+  va_list args;
+  va_start(args, fmt);
+  vsnprintf(buffer, 8192, fmt, args);
+  va_end(args);
+  return std::runtime_error(buffer);
+}
+
+// See http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert
+// Avoids unused variable warnings.
+#ifdef NDEBUG
+#define ZASSERT(x)    \
+  do {                \
+    (void) sizeof(x); \
+  } while (0)
+#else
+#define ZASSERT(x) assert(x)
+#endif
+
+#define ZALLOCATED(expr)                         \
+  do {                                           \
+    if ((expr) == NULL)                          \
+      throw std::runtime_error("Out of memory"); \
+  } while (0);
+
+}  // namespace odb

src/odb/include/odb/ZFactory.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "ZObject.h"
+#include "odb.h"
+
+namespace odb {
+
+class ZContext;
+class ZObject;
+class ZFactory;
+
+///
+/// ZFactory - Class factory interface
+///
+class ZFactory
+{
+ public:
+  //
+  // Return values:
+  //    Z_OK - Object created
+  //    Z_ERROR_NO_INTERFACE - Object not created because it does not
+  //                           support the specified interface.
+  //
+  virtual int create(const ZContext& context, ZInterfaceID iid, void** p) = 0;
+};
+
+///
+/// ZFactoryImpl - A singleton class which creates instances of the
+/// implementation class.
+///
+template <class IMPL, class INFC>
+class ZFactoryImpl : public ZFactory
+{
+ public:
+  int create(const ZContext& context, ZInterfaceID iid, void** p)
+  {
+    IMPL* o = new IMPL;
+    o->_context = context;
+
+    if (o->QueryInterface(iid, p) == Z_OK)
+      return Z_OK;
+
+    delete o;
+    *p = NULL;
+    return Z_ERROR_NO_INTERFACE;
+  }
+};
+
+}  // namespace odb

src/odb/include/odb/ZInterface.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <vector>
+
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#include "ZException.h"
+#include "geom.h"
+#include "odb.h"
+
+namespace odb {
+
+class dbDatabase;
+class ZSession;
+class ZObject;
+class dbObject;
+
+/////////////////////////////////
+/// Event value types
+/////////////////////////////////
+enum ZValueType
+{
+  Z_CHAR,
+  Z_UCHAR,
+  Z_SHORT,
+  Z_USHORT,
+  Z_INT,
+  Z_UINT,
+  Z_FLOAT,
+  Z_DOUBLE,
+  Z_STRING,
+  Z_BOOL,
+  Z_ZOBJECT,
+  Z_DBOBJECT
+};
+
+/////////////////////////////////////////////////////
+/// ZContext - Context the software is running in.
+/////////////////////////////////////////////////////
+class ZContext
+{
+ public:
+  Tcl_Interp* _interp;
+  ZSession* _session;
+};
+
+//////////////////////////////////////////////
+/// Interface to zroute software architecture
+//////////////////////////////////////////////
+class ZInterface
+{
+ public:
+  ZInterface();
+  virtual ~ZInterface();
+
+  //
+  // Post an event. This method specifies the event as a series of attribute
+  // value pairs. There must be a at least one attribute value pair. Furthermore
+  // the series of attribute value pairs must be terminated with a zero. For
+  // examples:
+  //    int x, y;
+  //    ...
+  //    z->event("foo", "x", Z_INT, x, "y", Z_INT, y, 0 );
+  //
+  // Throws ZException
+  int event(const char* name, const char* attr1, int type, ...);
+
+  //
+  // Post an event. This method specifies the event as a series of attribute
+  // value pairs. There must be a at least one attribute value pair. Furthermore
+  // the series of attribute value pairs must be terminated with a zero. For
+  // examples:
+  //    int x, y;
+  //    ...
+  //    z->event("foo", "x", "10", "y", "11", 0 );
+  // Throws ZException
+  int event(const char* name, const char* attr1, const char* val, ...);
+
+  // idle event
+  int idle(int level);
+
+  // ade event
+  int ade(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // milos event
+  int milos(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // warning message
+  int warning(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // informational message
+  int info(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // informational message
+  int notice(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // verbose/debugging message
+  int verbose(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // debug message
+  // void debug(const char *mod, const char *tag, const char * fmt, ... )
+  // ADS_FORMAT_PRINTF(4,5);
+
+  // error, Throws a ZException
+  void error(int code, const char* fmt, ...) ADS_FORMAT_PRINTF(3, 4);
+
+  // Get the name of this module
+  virtual const char* getModuleName() { return ""; }
+
+ public:
+  ZContext _context;
+};
+
+}  // namespace odb

src/odb/include/odb/ZNamespace.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <string.h>
+
+#include <map>
+#include <vector>
+
+#include "odb.h"
+
+namespace odb {
+
+class ZObject;
+class dbDatabase;
+class dbObject;
+
+////////////////////////////////////
+/// ZNamespace
+////////////////////////////////////
+class ZNamespace
+{
+  struct ltstr
+  {
+    bool operator()(const char* s1, const char* s2) const
+    {
+      return strcmp(s1, s2) < 0;
+    }
+  };
+
+  class ZEntry;
+  class dbEntry;
+
+  std::map<ZObject*, ZEntry*> _zobj_entries;
+  std::map<dbDatabase*, dbEntry*> _db_entries;
+  std::map<const char*, ZEntry*, ltstr> _zobj_names;
+  std::map<const char*, dbEntry*, ltstr> _db_names;
+  uint _unique_id;
+
+ public:
+  ZNamespace();
+  ~ZNamespace();
+
+  // These functions may throw a ZException
+  const char* addZObject(ZObject* obj);
+  void removeZObject(ZObject* obj);
+  ZObject* resolveZObject(const char* zname);
+  void registerDb(dbDatabase* db);
+  void unregisterDb(dbDatabase* db);
+  dbObject* resolveDB(const char* dbname);
+};
+
+}  // namespace odb

src/odb/include/odb/ZObject.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "ZComponents.h"
+#include "ZException.h"
+#include "odb.h"
+
+///
+/// This file contains an implmentation of a component based software
+/// architecture. This implementation is strictly for C++ interfaces. There is
+/// no support for external language bindings. And there is no support for
+/// multiple interfaces (QueryInterface: one interface is supported per
+/// implementation).
+///
+
+namespace odb {
+
+template <class T>
+class ZPtr;
+class ZContext;
+class ZObject;
+
+#define Z_SUCCEEDED(r) (r == Z_OK)
+#define Z_FAILED(r) (r != Z_OK)
+#define Z_OK 0
+#define Z_ERROR_NO_INTERFACE 1
+#define Z_ERROR_OUT_OF_MEMORY 2
+#define Z_ERROR_NO_COMPONENT 3
+
+///
+/// ZINTERFACE_ID -
+/// Associate the interface identifier this the interface. This macro
+/// should be added to the public section of the interface class.
+///
+#define ZINTERFACE_ID(INTERFACE) \
+  enum                           \
+  {                              \
+    ZIID = ZIID_##INTERFACE      \
+  }
+
+///
+/// ZCID - Returns the component interface identifier. You must include
+/// ZComponents.h to use this macro.
+///
+#define ZCID(COMPONENT) (ZCID_##COMPONENT)
+
+///
+/// ZIID - Returns the component interface identifier. You must include
+/// ZComponents.h to use this macro.
+///
+#define ZIID(INTERFACE) (ZIID_##INTERFACE)
+
+///
+/// adsCreateComponent - Create a new instance of this compomnent, return a
+/// pointer to the specified interface.
+///
+/// Returns: Z_OK, Z_ERROR_NO_COMPONENT, Z_ERROR_NO_INTERFACE
+///
+/// result is set to the interface pointer on success, otherwise it is set to
+/// NULL.
+///
+int adsCreateComponent(const ZContext& context,
+                       ZComponentID cid,
+                       ZInterfaceID iid,
+                       void** result);
+
+///
+/// adsNewComponent - Creates a component specified by the component-identifier.
+/// The ZPtr is assigned the specified interface of this component. A run-time
+/// error will occur if this component does not support the specified interface.
+///
+template <class INTERFACE>
+inline int adsNewComponent(const ZContext& context,
+                           ZComponentID cid,
+                           ZPtr<INTERFACE>& ptr)
+{
+  INTERFACE* p;
+  ZInterfaceID iid = (ZInterfaceID) INTERFACE::ZIID;
+  int r = adsCreateComponent(context, cid, iid, (void**) &p);
+
+  ptr = (INTERFACE*) p;
+
+  if (r == Z_OK)
+    p->Release();
+
+  return r;
+}
+
+///
+/// ZObject - Base class of all interfaces.
+///
+class ZObject
+{
+ public:
+  typedef ZObject _zobject_traits;
+  enum
+  {
+    ZIID = 0
+  };
+  ZObject();
+  virtual ~ZObject();
+  virtual uint AddRef() = 0;
+  virtual uint Release() = 0;
+  virtual int QueryInterface(ZInterfaceID iid, void** ref) = 0;
+};
+
+///
+/// ZPtr - Smart pointer class to access methods of interface.
+///
+template <class T>
+class ZPtr
+{
+  T* _p;
+
+  void setPtr(T* p)
+  {
+    if (_p)
+      _p->Release();
+
+    _p = p;
+  }
+
+  T& operator*();  // Do not allow derefencing.
+
+ public:
+  ZPtr() { _p = NULL; }
+
+  ZPtr(ZObject* p)
+  {
+    if (p == NULL)
+      _p = NULL;
+    else {
+      void* v;
+      int r = p->QueryInterface((ZInterfaceID) T::ZIID, &v);
+
+      if (r != Z_OK) {
+        assert(r == Z_OK);  // throw the assert in debug mode
+        throw ZException("ZPtr: Invalid interface assignment");
+      }
+
+      _p = (T*) v;
+    }
+  }
+
+  ZPtr(const ZPtr<T>& p)
+  {
+    _p = p._p;
+
+    if (_p)
+      _p->AddRef();
+  }
+
+  ~ZPtr()
+  {
+    if (_p)
+      _p->Release();
+  }
+
+  ZPtr<T>& operator=(ZObject* p)
+  {
+    if (p == NULL)
+      setPtr(NULL);
+    else {
+      void* v;
+      int r = p->QueryInterface((ZInterfaceID) T::ZIID, &v);
+
+      if (r != Z_OK) {
+        assert(r == Z_OK);  // throw the assert in debug mode
+        throw ZException("ZPtr: Invalid interface assignment");
+      }
+
+      setPtr((T*) v);
+    }
+
+    return *this;
+  }
+
+  ZPtr<T>& operator=(ZPtr<T>& p)
+  {
+    if (this != &p) {
+      setPtr(p._p);
+
+      if (_p)
+        _p->AddRef();
+    }
+
+    return *this;
+  }
+
+  bool operator==(const ZPtr<T>& p) const { return _p == p._p; }
+  bool operator!=(const ZPtr<T>& p) const { return _p != p._p; }
+  bool operator==(const T* p) const { return _p == p; }
+  bool operator!=(const T* p) const { return _p != p; }
+
+  // pointer operator
+  T* operator->() { return _p; }
+
+  // get the pointer
+  T* getPtr() { return _p; }
+
+  // cast operator to a ZObject
+  operator ZObject*() const { return (ZObject*) _p; }
+};
+
+}  // namespace odb

src/odb/include/odb/ZSession.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "ZInterface.h"
+
+namespace odb {
+
+class ZNamespace;
+
+class ZSession : public ZInterface
+{
+ public:
+  ZNamespace* _ns;
+  dbDatabase* _db;
+
+  ZSession();
+  ~ZSession();
+  friend class ZInterface;
+};
+
+}  // namespace odb

src/odb/include/odb/array1.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+namespace odb {
+
+template <class T>
+class Ath__array1D
+{
+ private:
+  T* _array;
+  int _size;
+  int _chunk;
+  int _current;
+  int _iterCnt;
+
+ public:
+  Ath__array1D(int chunk = 0)
+  {
+    _chunk = chunk;
+    if (_chunk <= 0)
+      _chunk = 1024;
+
+    _current = 0;
+    if (chunk > 0) {
+      _size = _chunk;
+      _array = (T*) realloc(NULL, _size * sizeof(T));
+    } else {
+      _size = 0;
+      _array = NULL;
+    }
+    _iterCnt = 0;
+  }
+  ~Ath__array1D()
+  {
+    if (_array != NULL)
+      ::free(_array);
+  }
+  int add(T t)
+  {
+    if (_current >= _size) {
+      _size += _chunk;
+      _array = (T*) realloc(_array, _size * sizeof(T));
+    }
+    int n = _current;
+    _array[_current++] = t;
+
+    return n;
+  }
+  int reSize(int maxSize)
+  {
+    if (maxSize < _size)
+      return _size;
+
+    _size = (maxSize / _chunk + 1) * _chunk;
+    _array = (T*) realloc(_array, _size * sizeof(T));
+
+    if (_array == NULL) {
+      fprintf(stderr, "Cannot allocate array of size %d\n", _size);
+      assert(0);
+    }
+    return _size;
+  }
+  T* getTable() { return _array; }
+  T& get(int i)
+  {
+    assert((i >= 0) && (i < _current));
+
+    return _array[i];
+  }
+  T& geti(int i)
+  {
+    if (i >= _size)
+      reSize(i + 1);
+
+    return _array[i];
+  }
+  T& getLast()
+  {
+    assert(_current - 1 >= 0);
+
+    return _array[_current - 1];
+  }
+  void clear(T t)
+  {
+    for (int ii = 0; ii < _size; ii++)
+      _array[ii] = t;
+  }
+  int findIndex(T t)
+  {
+    for (int ii = 0; ii < _current; ii++) {
+      if (_array[ii] == t) {
+        return ii;
+      }
+    }
+
+    return -1;
+  }
+  int findNextBiggestIndex(T t, int start = 0)
+  {
+    for (int ii = start; ii < _current; ii++) {
+      if (t == _array[ii])
+        return ii;
+      if (t < _array[ii])
+        return ii > 0 ? ii - 1 : 0;
+    }
+    return _current;
+  }
+
+  bool notEmpty()
+  {
+    if (_current > 0)
+      return true;
+    else
+      return false;
+  }
+  bool getNext(T& a)
+  {
+    if (_iterCnt < _current) {
+      a = _array[_iterCnt++];
+      return true;
+    } else
+      return false;
+  }
+  T& pop()
+  {
+    assert(_current > 0);
+
+    _current--;
+
+    return _array[_current];
+  }
+  unsigned int getSize(void) { return _size; }
+  void resetIterator(unsigned int v = 0) { _iterCnt = v; }
+  void resetCnt(unsigned int v = 0)
+  {
+    _current = v;
+    _iterCnt = v;
+  }
+  unsigned int getCnt(void) { return _current; }
+  void set(int ii, T t)
+  {
+    if (ii >= _size)
+      reSize(ii + 1);
+
+    _array[ii] = t;
+  }
+};
+
+}  // namespace odb

src/odb/include/odb/array2d.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "name.h"
+#include "parse.h"
+#include "util.h"
+
+namespace odb {
+
+template <class T>
+class Ath__array2d
+{
+ private:
+  AthArray<T>** _array;
+  unsigned int _bankCnt;
+  uint _tmpBank;
+  uint _tmpCnt;
+  uint _current;
+  bool _doIteratorAll;
+
+ public:
+  Ath__array2d(
+      unsigned int bCnt)  // for bCnt small and each bank= 10000 max, for quad
+  {
+    _bankCnt = 4;
+    if (bCnt > 0)
+      _bankCnt = bCnt;
+
+    _array = new AthArray<T>*[_bankCnt];
+    assert(_array);
+
+    unsigned int ii;
+    for (ii = 0; ii < bCnt; ii++) {
+      _array[ii] = new AthArray<T>(128);
+      assert(_array[ii]);
+    }
+    resetIteratorFlags();
+  }
+  void resetIteratorFlags()
+  {
+    _tmpBank = 0;
+    _tmpCnt = 0;
+    _current = 0;
+    _doIteratorAll = false;
+  }
+  Ath__array2d(int bCnt, bool)  // for max 1024 and 128, for quad
+  {
+    _bankCnt = 32;
+    if (bCnt > 0)
+      _bankCnt = bCnt;
+
+    _array = new AthArray<T>*[_bankCnt];
+    assert(_array);
+
+    _array[0] = new AthArray<T>(3);
+    assert(_array[0]);
+
+    unsigned int halfCnt = _bankCnt / 2 + 1;
+
+    unsigned int ii;
+    for (ii = 1; ii < halfCnt; ii++) {
+      _array[ii] = new AthArray<T>(64);
+      assert(_array[ii]);
+    }
+    for (ii = halfCnt; ii < _bankCnt; ii++) {
+      _array[ii] = new AthArray<T>(4);
+      assert(_array[ii]);
+    }
+    resetIteratorFlags();
+  }
+  Ath__array2d(int bCnt, uint quarterSize1, uint quarterSize2, uint halfSize2)
+  {
+    _bankCnt = 32;
+    if (bCnt > 0)
+      _bankCnt = bCnt;
+
+    _array = new AthArray<T>*[_bankCnt];
+    assert(_array);
+
+    _array[0] = new AthArray<T>(4);
+    assert(_array[0]);
+
+    unsigned int halfCnt = _bankCnt / 2 + 1;
+    unsigned int quarterCnt = halfCnt / 2 + 1;
+
+    unsigned int ii;
+    for (ii = 1; ii < quarterCnt; ii++) {
+      _array[ii] = new AthArray<T>(quarterSize1);
+      assert(_array[ii]);
+    }
+    for (ii = quarterCnt; ii < halfCnt; ii++) {
+      _array[ii] = new AthArray<T>(quarterSize2);
+      assert(_array[ii]);
+    }
+    for (ii = halfCnt; ii < _bankCnt; ii++) {
+      _array[ii] = new AthArray<T>(halfSize2);
+      assert(_array[ii]);
+    }
+    resetIteratorFlags();
+  }
+
+  ~Ath__array2d()
+  {
+    for (unsigned int ii = 0; ii < _bankCnt; ii++)
+      delete _array[ii];
+    delete _array;
+  }
+  uint getBankCnt() { return _bankCnt; }
+  uint getCnt()
+  {
+    uint cnt = 0;
+    for (unsigned int ii = 0; ii < _bankCnt; ii++)
+      cnt += getCnt(ii);
+
+    return cnt;
+  }
+  unsigned int add(unsigned int ii, T a)
+  {
+    if (ii >= _bankCnt)
+      ii = _bankCnt - 1;
+
+    return _array[ii]->add(a);
+  }
+  T get(int ii, int jj) { return _array[ii]->get(jj); }
+  unsigned int getCnt(unsigned int ii) { return _array[ii]->getLast(); }
+  unsigned int startIterator(unsigned int ii)
+  {
+    _doIteratorAll = false;
+    _tmpBank = ii;
+    _current = 0;
+    if (ii < _bankCnt)
+      _tmpCnt = _array[ii]->getLast();
+    else
+      _tmpCnt = 0;
+
+    return _tmpCnt;
+  }
+  unsigned int startIteratorAll()
+  {
+    uint cnt = startIterator(0);
+    _doIteratorAll = true;
+    return cnt;
+  }
+  int getNext(T* a)
+  {
+    if (_current < _tmpCnt) {
+      *a = _array[_tmpBank]->get(_current++);
+      return _current;
+    } else if (_doIteratorAll) {
+      _tmpBank++;
+      if (_tmpBank == _bankCnt)
+        return 0;
+
+      startIterator(_tmpBank);
+      _doIteratorAll = true;
+
+      return getNext(a);
+    } else {
+      return 0;
+    }
+  }
+
+  void printCnt(FILE* fp, uint ii, char* msg)
+  {
+    fprintf(fp, "%6d %s\n", getCnt(ii), msg);
+  }
+  void printAllCnts(FILE* fp, char* indexMsg, char* msg)
+  {
+    for (unsigned int ii = 0; ii < _bankCnt; ii++) {
+      if (getCnt(ii) <= 0)
+        continue;
+      fprintf(fp, "%s= %2d has ", indexMsg, ii);
+      printCnt(fp, ii, msg);
+    }
+  }
+};
+
+}  // namespace odb

src/odb/include/odb/box.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <stdio.h>
+#include <string.h>
+
+#include "util.h"
+
+namespace odb {
+
+using uint = unsigned int;
+
+bool Ath__intersect(int X1, int DX, int x1, int dx, int* ix1, int* ix2);
+
+// TODO center line with width and length and direction
+
+class Ath__box
+{
+ public:
+  uint _layer : 4;
+  uint _valid : 1;
+  uint _id : 28;
+
+ public:
+  int _xlo;
+  int _ylo;
+  int _xhi;
+  int _yhi;
+  Ath__box* _next;
+
+ public:
+  Ath__box();
+  uint getDir();
+  int getYhi(int bound);
+  int getXhi(int bound);
+  int getXlo(int bound);
+  int getYlo(int bound);
+  uint getWidth(uint* dir);
+  Ath__box(int x1, int y1, int x2, int y2, uint units = 1);
+  void set(int x1, int y1, int x2, int y2, uint units = 1);
+  uint getDX();
+  uint getDY();
+  uint getLength();
+  void invalidateBox();
+  void set(Ath__box* bb);
+  bool outside(int x1, int y1, int x2, int y2);
+  uint getOwner();
+};
+
+}  // namespace odb

src/odb/include/odb/cdl.h

+/////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2019, The Regents of the University of California
+// All rights reserved.
+//
+// BSD 3-Clause License
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <stdio.h>
+#include <unistd.h>
+
+#include <list>
+#include <string>
+
+#include "db.h"
+#include "odb.h"
+
+namespace odb {
+
+class cdl
+{
+ public:
+  static bool writeCdl(utl::Logger* logger,
+                       dbBlock* block,
+                       const char* outFileName,
+                       const std::vector<const char*>& mastersFileNames,
+                       bool includeFillers = 0);
+};
+
+}  // namespace odb

src/odb/include/odb/darr.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+/*-------------------------------------------------------------
+////	AUTHOR: SANJEEV MAHAJAN
+---------------------------------------------------------------*/
+#pragma once
+
+#include <stdlib.h>
+
+#include "assert.h"
+
+namespace odb {
+
+template <class T>
+class Darr
+{
+ public:
+  Darr(int n = 0);
+  ~Darr(void);
+  void insert(T el);
+  void remove(int i);
+  T pop();
+  T get(int i);
+  void set(int i, T el);
+  int n();
+  void dsort(int cmp(const void* a, const void* b));
+  void reset(int n = 0);
+
+ private:
+  T* _ar;
+  int _n;
+  int _tot;
+};
+
+template <class T>
+Darr<T>::Darr(int n)
+{
+  _n = 0;
+  _tot = n;
+  if (n == 0) {
+    _ar = NULL;
+    return;
+  }
+  _ar = new T[_tot];
+}
+template <class T>
+void Darr<T>::insert(T el)
+{
+  if (_n < _tot) {
+    _ar[_n++] = el;
+    return;
+  }
+  _tot = 2 * _tot + 1;
+  T* ara = new T[_tot];
+  int i;
+  for (i = 0; i < _n; i++)
+    ara[i] = _ar[i];
+  ara[_n++] = el;
+  if (_ar)
+    delete[] _ar;
+  _ar = ara;
+  return;
+}
+template <class T>
+void Darr<T>::remove(int i)
+{
+  assert(i < _n);
+  assert(i >= 0);
+  int j;
+  for (j = i + 1; j < _n; j++)
+    _ar[j - 1] = _ar[j];
+  _n--;
+}
+template <class T>
+T Darr<T>::pop()
+{
+  assert(_n > 0);
+  _n--;
+  return _ar[_n];
+}
+
+template <class T>
+T Darr<T>::get(int i)
+{
+  assert(i < _n);
+  assert(i >= 0);
+  return _ar[i];
+}
+template <class T>
+void Darr<T>::set(int i, T el)
+{
+  assert(i < _n);
+  assert(i >= 0);
+  _ar[i] = el;
+}
+template <class T>
+void Darr<T>::reset(int n)
+{
+  if (_n > n)
+    _n = n;
+  assert(_n <= _tot);
+}
+template <class T>
+int Darr<T>::n(void)
+{
+  return _n;
+}
+template <class T>
+Darr<T>::~Darr(void)
+{
+  if (_ar)
+    delete[] _ar;
+}
+template <class T>
+void Darr<T>::dsort(int cmp(const void* a, const void* b))
+{
+  qsort(_ar, _n, sizeof(T), cmp);
+}
+
+}  // namespace odb

src/odb/include/odb/dbBlockCallBackObj.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <list>
+
+#include "odb.h"
+
+namespace odb {
+
+class dbBlock;
+class dbBox;
+class dbFill;
+class dbInst;
+class dbMaster;
+class dbNet;
+class dbITerm;
+class dbWire;
+class dbBTerm;
+class dbBPin;
+class dbBlockage;
+class dbPlacementStatus;
+class dbObstruction;
+class dbRegion;
+class dbRow;
+class dbSBox;
+class dbSWire;
+///////////////////////////////////////////////////////////////////////////////
+///
+/// dbBlockCallBackObj - An object comprising a list of stub routines
+/// invoked by dbBlock.
+/// Derived classes may implement these routines, causing external code
+/// to be invoked from inside dbBlock methods.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+class dbBlockCallBackObj
+{
+ public:
+  // dbInst Start
+  virtual void inDbInstCreate(dbInst*) {}
+  virtual void inDbInstCreate(dbInst*, dbRegion*) {}
+  virtual void inDbInstDestroy(dbInst*) {}
+  virtual void inDbInstPlacementStatusBefore(dbInst*, const dbPlacementStatus&) {}
+  virtual void inDbInstSwapMasterBefore(dbInst*, dbMaster*) {}
+  virtual void inDbInstSwapMasterAfter(dbInst*) {}
+  virtual void inDbPreMoveInst(dbInst*) {}
+  virtual void inDbPostMoveInst(dbInst*) {}
+  // dbInst End
+
+  // dbNet Start
+  virtual void inDbNetCreate(dbNet*) {}
+  virtual void inDbNetDestroy(dbNet*) {}
+  // dbNet End
+
+  // dbITerm Start
+  virtual void inDbITermCreate(dbITerm*) {}
+  virtual void inDbITermDestroy(dbITerm*) {}  // Bugzilla #7 - payam
+  virtual void inDbITermPreDisconnect(dbITerm*) {}
+  virtual void inDbITermPostDisconnect(dbITerm*, dbNet*) {}
+  virtual void inDbITermPreConnect(dbITerm*, dbNet*) {}
+  virtual void inDbITermPostConnect(dbITerm*) {}
+  // dbITerm End
+
+  // dbBTerm Start
+  virtual void inDbBTermCreate(dbBTerm*) {}
+  virtual void inDbBTermDestroy(dbBTerm*) {}
+  virtual void inDbBTermPreConnect(dbBTerm*, dbNet*) {}
+  virtual void inDbBTermPostConnect(dbBTerm*) {}
+  virtual void inDbBTermPreDisconnect(dbBTerm*) {}
+  virtual void inDbBTermPostDisConnect(dbBTerm*, dbNet*) {}
+  // dbBTerm End
+
+  // dbBPin Start
+  virtual void inDbBPinCreate(dbBPin*) {}
+  virtual void inDbBPinDestroy(dbBPin*) {}
+  // dbBPin End
+
+  // dbBlockage Start
+  virtual void inDbBlockageCreate(dbBlockage*) {}
+  // dbBlockage End
+
+  // dbObstruction Start
+  virtual void inDbObstructionCreate(dbObstruction*) {}
+  virtual void inDbObstructionDestroy(dbObstruction*) {}
+  // dbObstruction End
+
+  // dbRegion Start
+  virtual void inDbRegionCreate(dbRegion*) {}
+  virtual void inDbRegionAddBox(dbRegion*, dbBox*) {}
+  virtual void inDbRegionDestroy(dbRegion*) {}
+  // dbRegion End
+
+  // dbRow Start
+  virtual void inDbRowCreate(dbRow*) {}
+  virtual void inDbRowDestroy(dbRow*) {}
+  // dbRow End
+
+  // dbWire Start
+  virtual void inDbWireCreate(dbWire*) {}
+  virtual void inDbWireDestroy(dbWire*) {}
+  virtual void inDbWirePreAttach(dbWire*, dbNet*) {}
+  virtual void inDbWirePostAttach(dbWire*) {}
+  virtual void inDbWirePreDetach(dbWire*) {}
+  virtual void inDbWirePostDetach(dbWire*, dbNet*) {}
+  virtual void inDbWirePreAppend(dbWire*, dbWire*) {
+  }  // first is src, second is dst
+  virtual void inDbWirePostAppend(dbWire*, dbWire*) {
+  }  // first is src, second is dst
+  virtual void inDbWirePreCopy(dbWire*, dbWire*) {
+  }  // first is src, second is dst
+  virtual void inDbWirePostCopy(dbWire*, dbWire*) {
+  }  // first is src, second is dst
+  // dbWire End
+
+  // dbSWire Start
+  virtual void inDbSWireCreate(dbSWire*) {}
+  virtual void inDbSWireDestroy(dbSWire*) {}
+  virtual void inDbSWireAddSBox(dbSBox*) {}
+  virtual void inDbSWireRemoveSBox(dbSBox*) {}
+  virtual void inDbSWirePreDestroySBoxes(dbSWire*) {}
+  virtual void inDbSWirePostDestroySBoxes(dbSWire*) {}
+  // dbSWire End
+
+  // dbFill Start
+  virtual void inDbFillCreate(dbFill*) {}
+  // dbFill End
+
+  virtual void inDbBlockStreamOutBefore(dbBlock*) {}
+  virtual void inDbBlockStreamOutAfter(dbBlock*) {}
+  virtual void inDbBlockReadNetsBefore(dbBlock*) {}
+  virtual void inDbBlockSetDieArea(dbBlock*) {}
+  
+  // allow ECO client initialization - payam
+  virtual dbBlockCallBackObj& operator()() { return *this; }
+
+  // Manipulate _callback list of owner -- in journal.cpp
+  void addOwner(dbBlock* new_owner);
+  bool hasOwner() const { return (_owner != NULL); }
+  void removeOwner();
+
+  dbBlockCallBackObj() { _owner = NULL; }
+  virtual ~dbBlockCallBackObj() { removeOwner(); }
+
+ private:
+  dbBlock* _owner;
+};
+
+}  // namespace odb

src/odb/include/odb/dbBlockSet.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "dbObject.h"
+
+namespace odb {
+
+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:
+  typedef dbBlock* value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef dbBlock** pointer;
+  typedef dbBlock*& reference;
+  typedef std::input_iterator_tag iterator_category;
+
+  dbSetIterator()
+  {
+    _itr = NULL;
+    _cur = 0;
+    _parent = NULL;
+  }
+
+  dbSetIterator(const dbSetIterator& it)
+  {
+    _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);
+  }
+
+  bool operator!=(const dbSetIterator<dbBlock>& it)
+  {
+    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); }
+
+  dbSetIterator<dbBlock>& operator++()
+  {
+    _cur = _itr->next(_cur);
+    return *this;
+  }
+
+  dbSetIterator<dbBlock> operator++(int)
+  {
+    dbSetIterator it(*this);
+    _cur = _itr->next(_cur);
+    return it;
+  }
+};
+
+template <>
+class dbSet<dbBlock>
+{
+  dbIterator* _itr;
+  dbObject* _parent;
+
+ public:
+  typedef dbSetIterator<dbBlock> iterator;
+
+  dbSet()
+  {
+    _itr = NULL;
+    _parent = NULL;
+  }
+
+  dbSet(dbObject* parent, dbIterator* itr)
+  {
+    _parent = parent;
+    _itr = itr;
+  }
+
+  dbSet(const dbSet<dbBlock>& c)
+  {
+    _itr = c._itr;
+    _parent = c._parent;
+  }
+
+  ///
+  /// Returns the number of items in this set.
+  ///
+  uint size() { return _itr->size(_parent); }
+
+  ///
+  /// Return a begin() iterator.
+  ///
+  iterator begin() { return iterator(_itr, _itr->begin(_parent), _parent); }
+
+  ///
+  /// Return an end() iterator.
+  ///
+  iterator end() { return iterator(_itr, _itr->end(_parent), _parent); }
+
+  ///
+  /// Returns the maximum number sequential elements the this set
+  /// may iterate.
+  ///
+  uint sequential() { return _itr->sequential(); }
+
+  ///
+  /// Returns true if this set is 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(); }
+
+  ///
+  /// Reverse the order of this set.
+  ///
+  void reverse() { _itr->reverse(_parent); }
+};
+
+}  // namespace odb

src/odb/include/odb/dbCCSegSet.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "dbObject.h"
+
+namespace odb {
+
+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:
+  typedef dbCCSeg* value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef dbCCSeg** pointer;
+  typedef dbCCSeg*& reference;
+  typedef std::input_iterator_tag iterator_category;
+
+  dbSetIterator()
+  {
+    _itr = NULL;
+    _cur = 0;
+    _pid = 0;
+  }
+
+  dbSetIterator(const dbSetIterator& it)
+  {
+    _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);
+  }
+
+  bool operator!=(const dbSetIterator<dbCCSeg>& it)
+  {
+    return (_itr != it._itr) || (_cur != it._cur) || (_pid != it._pid);
+  }
+
+  dbCCSeg* operator*() { return (dbCCSeg*) _itr->getObject(_cur); }
+
+  dbCCSeg* operator->() { return (dbCCSeg*) _itr->getObject(_cur); }
+
+  dbSetIterator<dbCCSeg>& operator++()
+  {
+    _cur = _itr->next(_cur, _pid);
+    return *this;
+  }
+
+  dbSetIterator<dbCCSeg> operator++(int)
+  {
+    dbSetIterator it(*this);
+    _cur = _itr->next(_cur, _pid);
+    return it;
+  }
+};
+
+template <>
+class dbSet<dbCCSeg>
+{
+  dbIterator* _itr;
+  dbObject* _parent;
+  uint _pid;
+
+ public:
+  typedef dbSetIterator<dbCCSeg> iterator;
+
+  dbSet()
+  {
+    _itr = NULL;
+    _parent = NULL;
+    _pid = 0;
+  }
+
+  dbSet(dbObject* parent, dbIterator* itr)
+  {
+    _parent = parent;
+    _itr = itr;
+    _pid = parent->getId();
+  }
+
+  dbSet(const dbSet<dbCCSeg>& c)
+  {
+    _itr = c._itr;
+    _parent = c._parent;
+    _pid = c._pid;
+  }
+
+  ///
+  /// Returns the number of items in this set.
+  ///
+  uint size() { return _itr->size(_parent); }
+
+  ///
+  /// Return a begin() iterator.
+  ///
+  iterator begin() { return iterator(_itr, _itr->begin(_parent), _pid); }
+
+  ///
+  /// Return an end() iterator.
+  ///
+  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(); }
+
+  ///
+  /// Returns true if this set is 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(); }
+
+  ///
+  /// Reverse the order of this set.
+  ///
+  void reverse() { _itr->reverse(_parent); }
+};
+
+}  // namespace odb

src/odb/include/odb/dbExtControl.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "db.h"
+
+namespace odb {
+
+class dbExtControl : public dbObject
+{
+ public:
+  // PERSISTANT-MEMBERS
+  bool _independentExtCorners;
+  bool _foreign;
+  bool _wireStamped;
+  bool _rsegCoord;
+  bool _overCell;
+  bool _extracted;
+  bool _lefRC;
+  uint _cornerCnt;
+  uint _ccPreseveGeom;
+  uint _ccUp;
+  uint _couplingFlag;
+  double _coupleThreshold;
+  double _mergeResBound;
+  bool _mergeViaRes;
+  bool _mergeParallelCC;
+  bool _exttreePreMerg;
+  double _exttreeMaxcap;
+  bool _useDbSdb;
+  uint _CCnoPowerSource;
+  uint _CCnoPowerTarget;
+  bool _usingMetalPlanes;
+  std::string _ruleFileName;
+  std::string _extractedCornerList;
+  std::string _derivedCornerList;
+  std::string _cornerIndexList;
+  std::string _resFactorList;
+  std::string _gndcFactorList;
+  std::string
+  _ccFactorList;
+
+  dbExtControl();
+};
+
+dbOStream& operator<<(dbOStream& stream, const dbExtControl& extControl);
+dbIStream& operator>>(dbIStream& stream, dbExtControl& extControl);
+
+}  // namespace odb

src/odb/include/odb/dbId.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "dbStream.h"
+
+namespace odb {
+
+class dbIdValidation
+{
+ public:
+  static uint invalidId() { return 0; }
+  static bool isId(const char* inid);
+};
+
+//
+// April 2006 twg -
+//
+//     I removed the inheritance of empty class dbIdValidation from the
+//     inheritance list of dbId. The "C++" standard does not enforce an empty
+//     class to have zero bytes. It is up to the compiler to optimize the empty
+//     class.
+//
+//     If the compiler does NOT optimize the empty class, then database index
+//     will increase from 32-bits to 64-bits! (the compiler will align the "_id"
+//     field to a 32-bit boundary.)
+//
+template <class T>
+class dbId
+{
+  unsigned int _id;
+
+ public:
+  typedef T _type;
+
+  dbId() { _id = 0; }
+  dbId(const dbId<T>& id) : _id(id._id) {}
+  dbId(unsigned int id) { _id = id; }
+
+  operator unsigned int() const { return _id; }
+  unsigned int& id() { return _id; }
+
+  bool isValid() { return _id > 0; }
+
+  friend dbOStream& operator<<(dbOStream& stream, const dbId<T>& id)
+  {
+    stream << id._id;
+    return stream;
+  }
+
+  friend dbIStream& operator>>(dbIStream& stream, dbId<T>& id)
+  {
+    stream >> id._id;
+    return stream;
+  }
+};
+
+}  // namespace odb

src/odb/include/odb/dbIterator.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <iterator>
+
+#include "odb.h"
+
+namespace odb {
+
+class dbObject;
+class dbObjectTable;
+
+class dbIterator
+{
+ public:
+  virtual bool reversible() = 0;
+  virtual bool orderReversed() = 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 dbObject* getObject(uint id, ...) = 0;
+  virtual ~dbIterator() {}
+};
+
+}  // namespace odb

src/odb/include/odb/dbLogger.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/times.h>
+
+#include "ZInterface.h"
+#include "odb.h"
+
+namespace odb {
+
+int idle(int = 0);
+
+int notice(int code, const char* msg, ...) ADS_FORMAT_PRINTF(2, 3);
+int verbose(int code, const char* msg, ...) ADS_FORMAT_PRINTF(2, 3);
+
+int info(int code, const char* msg, ...) ADS_FORMAT_PRINTF(2, 3);
+
+void dumpWarn();
+int checkWarning(const char* msg);
+void resetWarningCount(const char* msg, int max, int cnt);
+
+int warning(int code, const char* msg, ...) ADS_FORMAT_PRINTF(2, 3);
+
+void error(int code, const char* msg, ...) ADS_FORMAT_PRINTF(2, 3);
+
+int debug(const char* mod, const char* tag, const char* msg, ...)
+    ADS_FORMAT_PRINTF(3, 4);
+int isDebug(const char* mod, const char* tag);
+
+}  // namespace odb

src/odb/include/odb/dbMap.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "dbSet.h"
+#include "odb.h"
+
+namespace odb {
+
+///
+/// This class creates a assocation between
+/// the objects of dbSet<T> to a an object of type "D".
+/// If "D" is a class object, then "D" must have a public default constructor
+/// and a public destructor.
+///
+/// NOTE: The map becomes invalid if the dbSet membership changes, i.e.,
+/// a member is added or deleted from the set.
+///
+/// If the map becomes invalid, access operations may fail.
+///
+template <class T, class D>
+class dbMap
+{
+  dbSet<T> _set;
+  std::map<T*, D>* _map;    // map used if set is not sequential
+  std::vector<D>* _vector;  // vector used if set is sequential
+
+  // Map cannot be assigned or copied!
+  dbMap(const dbMap&);
+  dbMap& operator=(const dbMap&);
+
+ public:
+  ///
+  /// Create a new map from the set. The data-objects are initialized
+  /// to the default constructor of the object type.
+  ///
+  dbMap(const dbSet<T>& set);
+
+  ///
+  /// Destructor.
+  ///
+  ~dbMap();
+
+  ///
+  /// D & operator[T *] const
+  /// Access to a data object of key "T *".
+  ///
+  /// Example:
+  ///
+  /// dbSet<dbNet> nets = block->getNets();
+  /// dbMap<dbNet, int> net_weight;
+  /// dbSet<dbNet>::iterator itr;
+  ///
+  /// for( itr = nets.begin(); itr != nets.end(); ++itr )
+  /// {
+  ///     dbNet * net = *itr;
+  ///     net_weight[net] = 1;
+  /// }
+  ///
+  D& operator[](T* object);
+
+  ///
+  /// const D & operator[T *] const
+  /// Const access to a data object of key "T *".
+  ///
+  /// Example:
+  ///
+  /// dbSet<dbNet> nets = block->getNets();
+  /// dbMap<dbNet, int> net_weight;
+  /// dbSet<dbNet>::iterator itr;
+  ///
+  /// for( itr = nets.begin(); itr != nets.end(); ++itr )
+  /// {
+  ///     dbNet * net = *itr;
+  ///     int weight = net_weight[net];
+  ///     printf("net(%d) weight = %d\n", net->getId(), weight );
+  /// }
+  ///
+  const D& operator[](T* object) const;
+};
+
+}  // namespace odb
+
+#include "dbMap.hpp"

src/odb/include/odb/dbMap.hpp

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "ZException.h"
+
+namespace odb {
+
+template <class T, class D>
+inline dbMap<T, D>::dbMap(const dbSet<T>& set)
+{
+  _set = set;
+
+  // Use a vector if this set represents a sequential iterator
+  if (_set.sequential()) {
+    _vector = new std::vector<D>(_set.sequential() + 1);
+    _map    = NULL;
+  }
+
+  // Use a map if this set represents random iterator
+  else {
+    _vector = NULL;
+    _map    = new std::map<T*, D>;
+    typename dbSet<T>::iterator itr;
+
+    for (itr = _set.begin(); itr != _set.end(); ++itr) {
+      T* object       = *itr;
+      (*_map)[object] = D();
+    }
+  }
+}
+
+template <class T, class D>
+inline dbMap<T, D>::~dbMap()
+{
+  if (_map)
+    delete _map;
+
+  if (_vector)
+    delete _vector;
+}
+
+template <class T, class D>
+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());
+    return (*itr).second;
+  }
+
+  uint idx = object->getId();
+  ZASSERT(idx && (idx < _vector->size()));
+  return (*_vector)[idx];
+}
+
+template <class T, class D>
+inline D& dbMap<T, D>::operator[](T* object)
+{
+  if (_map) {
+    typename std::map<T*, D>::iterator itr = _map->find(object);
+    ZASSERT(itr != _map->end());
+    return (*itr).second;
+  }
+
+  uint idx = object->getId();
+  ZASSERT(idx && (idx < _vector->size()));
+  return (*_vector)[idx];
+}
+
+}  // namespace odb
+
+

src/odb/include/odb/dbMatrix.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <vector>
+
+#include "dbDiff.h"
+#include "dbStream.h"
+#include "odb.h"
+
+namespace odb {
+class dbDiff;
+
+template <class T>
+class dbMatrix
+{
+ public:
+  uint _n;
+  uint _m;
+  std::vector<std::vector<T>> _matrix;
+
+  dbMatrix();
+  dbMatrix(uint n, uint m);
+  void resize(uint n, uint m);
+  uint numRows() const { return _n; }
+  uint numCols() const { return _m; }
+  void clear();
+  uint numElems() const;
+
+  dbMatrix(const dbMatrix<T>& incpy)
+      : _n(incpy._n), _m(incpy._m), _matrix(incpy._matrix)
+  {
+  }
+
+  dbMatrix<T>& operator=(const dbMatrix<T>& incpy)
+  {
+    _n = incpy._n;
+    _m = incpy._m;
+    _matrix.clear();
+    _matrix = incpy._matrix;
+    return *this;
+  }
+  const T& operator()(uint i, uint j) const;
+  T& operator()(uint i, uint j);
+
+  bool operator==(const dbMatrix<T>& rhs) const;
+  bool operator!=(const dbMatrix<T>& rhs) const { return !operator==(rhs); }
+  void differences(dbDiff& diff,
+                   const char* field,
+                   const dbMatrix<T>& rhs) const;
+  void out(dbDiff& diff, char side, const char* field) const;
+};
+
+template <class T>
+inline dbOStream& operator<<(dbOStream& stream, const dbMatrix<T>& mat)
+{
+  stream << mat._n;
+  stream << mat._m;
+
+  uint i, j;
+
+  for (i = 0; i < mat._n; ++i) {
+    for (j = 0; j < mat._m; ++j) {
+      const T& x = mat(i, j);
+      stream << x;
+    }
+  }
+
+  return stream;
+}
+
+template <class T>
+inline dbIStream& operator>>(dbIStream& stream, dbMatrix<T>& mat)
+{
+  uint n;
+  uint m;
+
+  stream >> n;
+  stream >> m;
+  mat.resize(n, m);
+
+  uint i, j;
+
+  for (i = 0; i < mat._n; ++i) {
+    for (j = 0; j < mat._m; ++j) {
+      T& x = mat(i, j);
+      stream >> x;
+    }
+  }
+
+  return stream;
+}
+
+template <class T>
+inline dbMatrix<T>::dbMatrix()
+{
+  _n = 0;
+  _m = 0;
+}
+
+template <class T>
+inline dbMatrix<T>::dbMatrix(uint n, uint m)
+{
+  _n = n;
+  _m = m;
+  resize(n, m);
+}
+
+template <class T>
+inline void dbMatrix<T>::clear()
+{
+  _n = _m = 0;
+  _matrix.clear();
+}
+
+template <class T>
+inline uint dbMatrix<T>::numElems() const
+{
+  return (_n * _m);
+}
+
+template <class T>
+inline void dbMatrix<T>::resize(uint n, uint m)
+{
+  uint i;
+
+  _n = n;
+  _m = m;
+  _matrix.resize(n);
+
+  for (i = 0; i < _n; ++i)
+    _matrix[i].resize(m);
+}
+
+template <class T>
+inline const T& dbMatrix<T>::operator()(uint i, uint j) const
+{
+  assert((i >= 0) && (i < _n) && (j >= 0) && (j < _m));
+  const std::vector<T>& v = _matrix[i];
+  return v[j];
+}
+
+template <class T>
+inline T& dbMatrix<T>::operator()(uint i, uint j)
+{
+  assert((i >= 0) && (i < _n) && (j >= 0) && (j < _m));
+  std::vector<T>& v = _matrix[i];
+  return v[j];
+}
+
+template <class T>
+inline bool dbMatrix<T>::operator==(const dbMatrix<T>& rhs) const
+{
+  return _matrix == rhs._matrix;
+}
+
+template <class T>
+inline void dbMatrix<T>::differences(dbDiff& diff,
+                                     const char* field,
+                                     const dbMatrix<T>& rhs) const
+{
+  uint i, j;
+
+  for (i = 0; i < _n && i < rhs._n; ++i) {
+    for (j = 0; j < _m && j < rhs._m; ++j) {
+      const T& o1 = (*this) (i, j);
+      const T& o2 = rhs(i, j);
+
+      if (o1 != o2) {
+        diff.report("< %s[%d][%d] = ", field, i, j);
+        diff << o1;
+        diff << "\n";
+        diff.report("> %s[%d][%d] = ", field, i, j);
+        diff << o2;
+        diff << "\n";
+      }
+    }
+
+    if (j < _m) {
+      for (j = 0; j < _m; ++j) {
+        const T& o1 = (*this) (i, j);
+
+        diff.report("< %s[%d][%d] = ", field, i, j);
+        diff << o1;
+        diff << "\n";
+      }
+    }
+
+    if (j < rhs._m) {
+      for (j = 0; j < rhs._m; ++j) {
+        const T& o2 = rhs(i, j);
+        diff.report("> %s[%d][%d] = ", field, i, j);
+        diff << o2;
+        diff << "\n";
+      }
+    }
+  }
+
+  if (i < _n) {
+    for (; i < _n; ++i) {
+      for (j = 0; j < _m; ++j) {
+        const T& o1 = (*this) (i, j);
+        diff.report("< %s[%d][%d] = ", field, i, j);
+        diff << o1;
+        diff << "\n";
+      }
+    }
+  }
+
+  if (i < rhs._n) {
+    for (; i < rhs._n; ++i) {
+      for (j = 0; j < rhs._m; ++j) {
+        const T& o2 = rhs(i, j);
+        diff.report("> %s[%d][%d] = ", field, i, j);
+        diff << o2;
+        diff << "\n";
+      }
+    }
+  }
+}
+
+template <class T>
+inline void dbMatrix<T>::out(dbDiff& diff, char side, const char* field) const
+{
+  uint i, j;
+
+  for (i = 0; i < _n; ++i) {
+    for (j = 0; j < _m; ++j) {
+      const T& o1 = (*this) (i, j);
+      diff.report("%c %s[%d][%d] = ", side, field, i, j);
+      diff << o1;
+      diff << "\n";
+    }
+  }
+}
+
+}  // namespace odb

src/odb/include/odb/dbNetSet.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2020, The Regents of the University of California
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "dbObject.h"
+
+namespace odb {
+
+class dbNet;
+
+template <>
+class dbSetIterator<dbNet>
+{
+  friend class dbSet<dbNet>;
+
+  dbIterator* _itr;
+  uint _cur;
+  dbObject* _parent;
+
+  dbSetIterator(dbIterator* itr, uint id, dbObject* parent)
+  {
+    _itr = itr;
+    _cur = id;
+    _parent = parent;
+  }
+
+ public:
+  typedef dbNet* value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef dbNet** pointer;
+  typedef dbNet*& reference;
+  typedef std::input_iterator_tag iterator_category;
+
+  dbSetIterator()
+  {
+    _itr = NULL;
+    _cur = 0;
+    _parent = NULL;
+  }
+
+  dbSetIterator(const dbSetIterator& it)
+  {
+    _itr = it._itr;
+    _cur = it._cur;
+    _parent = it._parent;
+  }
+
+  bool operator==(const dbSetIterator<dbNet>& it)
+  {
+    return (_itr == it._itr) && (_cur == it._cur) && (_parent == it._parent);
+  }
+
+  bool operator!=(const dbSetIterator<dbNet>& it)
+  {
+    return (_itr != it._itr) || (_cur != it._cur) || (_parent != it._parent);
+  }
+
+  dbNet* operator*() { return (dbNet*) _itr->getObject(_cur, _parent); }
+
+  dbNet* operator->() { return (dbNet*) _itr->getObject(_cur, _parent); }
+
+  dbSetIterator<dbNet>& operator++()
+  {
+    _cur = _itr->next(_cur);
+    return *this;
+  }
+
+  dbSetIterator<dbNet> operator++(int)
+  {
+    dbSetIterator it(*this);
+    _cur = _itr->next(_cur);
+    return it;
+  }
+};
+
+template <>
+class dbSet<dbNet>
+{
+  dbIterator* _itr;
+  dbObject* _parent;
+
+ public:
+  typedef dbSetIterator<dbNet> iterator;
+
+  dbSet()
+  {
+    _itr = NULL;
+    _parent = NULL;
+  }
+
+  dbSet(dbObject* parent, dbIterator* itr)
+  {
+    _parent = parent;
+    _itr = itr;
+  }
+
+  dbSet(const dbSet<dbNet>& c)
+  {
+    _itr = c._itr;
+    _parent = c._parent;
+  }
+
+  ///
+  /// Returns the number of items in this set.
+  ///
+  uint size() { return _itr->size(_parent); }
+
+  ///
+  /// Return a begin() iterator.
+  ///
+  iterator begin() { return iterator(_itr, _itr->begin(_parent), _parent); }
+
+  ///
+  /// Return an end() iterator.
+  ///
+  iterator end() { return iterator(_itr, _itr->end(_parent), _parent); }
+
+  ///
+  /// Returns the maximum number sequential elements the this set
+  /// may iterate.
+  ///
+  uint sequential() { return _itr->sequential(); }
+
+  ///
+  /// Returns true if this set is 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(); }
+
+  ///
+  /// Reverse the order of this set.
+  ///
+  void reverse() { _itr->reverse(_parent); }
+
+  ///
+  /// Returns true if set is empty
+  ///
+  bool empty() { return begin() == end(); }
+};
+
+}  // namespace odb

src/odb/include/odb/dbObject.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "odb.h"
+namespace utl {
+class Logger;
+}
+namespace odb {
+
+///
+/// When adding a new database object, you must add a dbObjectType enumerator
+/// and edit dbObject.cpp and assign an unique "character" code for its
+/// database-name. See the methods:
+///    void getDbName( char name[max_name_length] );
+///    static dbObject * resolveDbName( dbDatabase * db, const char * name );
+/// in dbObject.cpp
+///
+class _dbDatabase;
+class dbOStream;
+class dbIStream;
+class dbObjectPage;
+class dbObjectTable;
+class dbDiff;
+class _dbObject;
+
+///
+/// Steps to add new objects -
+///      - add the "name_tbl" entry in dbObject.cpp
+///      - add the table entry to the getObjectTable method of the container
+///      object.
+///
+enum dbObjectType
+{
+  dbDatabaseObj,
+
+  // Design Objects
+  dbChipObj,
+  dbBlockObj,
+  dbInstHdrObj,
+  dbInstObj,
+  dbNetObj,
+  dbBTermObj,
+  dbITermObj,
+  dbBoxObj,
+  dbViaObj,
+  dbTrackGridObj,
+  dbObstructionObj,
+  dbBlockageObj,
+  dbWireObj,
+  dbSWireObj,
+  dbSBoxObj,
+  dbCapNodeObj,
+  dbRSegObj,
+  dbCCSegObj,
+  dbRowObj,
+  dbFillObj,
+  dbRegionObj,
+  dbHierObj,
+  dbBPinObj,
+  // Generator Code Begin DbObjectType
+  dbTechLayerObj,
+  dbTechLayerSpacingEolRuleObj,
+  dbTechLayerMinStepRuleObj,
+  dbTechLayerCornerSpacingRuleObj,
+  dbTechLayerSpacingTablePrlRuleObj,
+  dbTechLayerEolKeepOutRuleObj,
+  dbTechLayerCutClassRuleObj,
+  dbTechLayerCutSpacingRuleObj,
+  dbTechLayerCutSpacingTableOrthRuleObj,
+  dbTechLayerCutSpacingTableDefRuleObj,
+  dbTechLayerCutEnclosureRuleObj,
+  dbTechLayerEolExtensionRuleObj,
+  dbTechLayerArraySpacingRuleObj,
+  dbTechLayerWidthTableRuleObj,
+  dbTechLayerMinCutRuleObj,
+  dbGuideObj,
+  dbMetalWidthViaMapObj,
+  dbTechLayerAreaRuleObj,
+  dbModuleObj,
+  dbModInstObj,
+  dbGroupObj,
+  dbGCellGridObj,
+  dbAccessPointObj,
+  dbGlobalConnectObj,
+  dbPowerDomainObj,
+  dbLogicPortObj,
+  dbPowerSwitchObj,
+  dbIsolationObj,
+  // Generator Code End DbObjectType
+
+  // Lib Objects
+  dbLibObj,
+  dbSiteObj,
+  dbMasterObj,
+  dbMPinObj,
+  dbMTermObj,
+  dbTargetObj,
+  dbTechAntennaPinModelObj,
+
+  // Tech Objects
+  dbTechObj,
+  dbTechViaObj,
+  dbTechNonDefaultRuleObj,  // also a design object
+  dbTechLayerRuleObj,       // also a design object
+  dbTechSameNetRuleObj,
+  dbTechLayerSpacingRuleObj,
+  dbTechMinCutRuleObj,
+  dbTechMinEncRuleObj,
+  dbTechV55InfluenceEntryObj,
+  dbTechLayerAntennaRuleObj,
+  dbTechViaRuleObj,
+  dbTechViaGenerateRuleObj,
+  dbTechViaLayerRuleObj,
+
+  // Property
+  dbPropertyObj,
+  dbNameObj
+};
+
+class dbDatabase;
+
+class dbObject
+{
+ public:
+  dbObjectType getObjectType() const;
+  dbDatabase* getDb() const;
+  uint getId() const;
+  static const int max_name_length = 256;
+  void getDbName(char name[max_name_length]) const;
+  const char* getObjName() const;
+
+  static dbObject* resolveDbName(dbDatabase* db, const char* name);
+  static const char* getObjName(dbObjectType type);
+  // These are not intended for client use as the returned class is
+  // not exported.  They are for internal db convenience.
+  _dbObject* getImpl();
+  const _dbObject* getImpl() const;
+
+ protected:
+  dbObject() {}
+  ~dbObject() {}
+};
+
+}  // namespace odb

src/odb/include/odb/dbRtEdge.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "dbTypes.h"
+#include "geom.h"
+#include "odb.h"
+#include "odbDList.h"
+
+namespace odb {
+
+class dbVia;
+class dbTechVia;
+class dbTechLayerRule;
+class dbRtTree;
+class dbRtNode;
+
+// EndStyle - Defines the end style of a segment
+class dbRtEndStyle
+{
+ public:
+  // End-Types:
+  //     EXTENDED - segment extended 1/2 path-width
+  //     VARIABLE - segment extended variable amount
+  enum Type
+  {
+    EXTENDED,
+    VARIABLE
+  };
+
+ private:
+  Type _type;
+  int _ext;
+
+ public:
+  dbRtEndStyle() : _type(EXTENDED), _ext(0) {}
+
+  void setExtended()
+  {
+    _type = EXTENDED;
+    _ext = 0;
+  }
+
+  void setVariable(int ext)
+  {
+    _type = VARIABLE;
+    _ext = ext;
+  }
+
+  Type getType() const { return _type; }
+  int getExt() const { return _ext; }
+
+  bool operator==(const dbRtEndStyle& s) const
+  {
+    return (_type == s._type) && (_ext == s._ext);
+  }
+
+  bool operator!=(const dbRtEndStyle& s) const
+  {
+    return (_type != s._type) || (_ext != s._ext);
+  }
+
+  friend class dbRtTree;
+};
+
+// dbRtEdge - represents an edge in the routing tree.
+class dbRtEdge
+{
+  friend class dbRtTree;
+  friend class dbRtNode;
+  friend class dbRtNodeEdgeIterator;
+
+ public:
+  // If new edge types are added, the corresponding allocator/deallocator code
+  // must be updated in dbRtTree.cpp
+  enum Type
+  {
+    SEGMENT = 0,
+    TECH_VIA = 1,
+    VIA = 2,
+    SHORT = 3,
+    VWIRE = 4
+  };
+
+ protected:
+  Type _type;
+  dbRtNode* _src;
+  dbRtNode* _tgt;
+  dbWireType::Value _wire_type;
+  dbTechLayerRule* _non_default_rule;
+  double _r;
+  double _c;
+  dbRtTree* _rt_tree;
+  dbRtEdge* _next[2];
+  dbRtEdge* _prev[2];
+  DListEntry<dbRtEdge> _rt_edge;
+  int _shape_id;
+  uint _property;
+  bool _visited;
+
+  dbRtEdge(Type type, dbWireType::Value wire_type, dbTechLayerRule* rule)
+      : _type(type),
+        _src(NULL),
+        _tgt(NULL),
+        _wire_type(wire_type),
+        _non_default_rule(rule),
+        _r(0.0),
+        _c(0.0),
+        _rt_tree(NULL),
+        _shape_id(-1),
+        _property(0),
+        _visited(false)
+  {
+    _next[0] = NULL;
+    _next[1] = NULL;
+    _prev[0] = NULL;
+    _prev[1] = NULL;
+  }
+
+  dbRtNode* opposite(dbRtNode* n) const { return n == _src ? _tgt : _src; }
+  dbRtEdge*& prev(dbRtNode* node) { return node == _src ? _prev[0] : _prev[1]; }
+  dbRtEdge*& next(dbRtNode* node) { return node == _src ? _next[0] : _next[1]; }
+
+ public:
+  virtual ~dbRtEdge() {}
+  virtual void getBBox(Rect& bbox) = 0;
+
+  // Get the type of this node
+  Type getType() const { return _type; }
+
+  // Get the source edge of this node (A source node has NO directional
+  // significance)
+  dbRtNode* getSource() const { return _src; }
+
+  // Get the target edge of this node (A target node has NO directional
+  // significance)
+  dbRtNode* getTarget() const { return _tgt; }
+
+  // Get the opposite node of this node, assumes n == src or n == tgt
+  dbRtNode* getOpposite(dbRtNode* n) const { return opposite(n); }
+
+  // Set the wire-type of this edge.
+  void setWireType(dbWireType::Value value) { _wire_type = value; }
+
+  // Get the wire-type of this edge.
+  dbWireType::Value getWireType() const { return _wire_type; }
+
+  // Get the NonDefaultRule of this edge (returns NULL is there is no
+  // non-default-rule);
+  void setNonDefaultRule(dbTechLayerRule* rule) { _non_default_rule = rule; }
+
+  // Get the NonDefaultRule of this edge (returns NULL is there is no
+  // non-default-rule);
+  dbTechLayerRule* getNonDefaultRule() const { return _non_default_rule; }
+
+  // Set the resistance of this edge
+  void setResistance(double r) { _r = r; }
+
+  // Get the resistance of this edge
+  double getResistance() const { return _r; }
+
+  // Set the capacitance of this edge
+  void setCapacitance(double c) { _c = c; }
+
+  // Get the capacitance of this edge
+  double getCapacitance() const { return _c; }
+
+  // Get the value of the visited flag.
+  bool isVisited() const { return _visited; }
+
+  // Set the value of the visited flag.
+  void setVisited(bool value) { _visited = value; }
+
+  // Assign a property to this edge
+  void setProperty(uint property) { _property = property; }
+
+  // Assign a property to this edge
+  uint getProperty() { return _property; }
+
+  static DListEntry<dbRtEdge>* rtEdge(dbRtEdge* edge)
+  {
+    return &edge->_rt_edge;
+  }
+};
+
+// VIA edge
+class dbRtVia : public dbRtEdge
+{
+  dbVia* _via;
+
+  dbRtVia(dbVia* via, dbWireType::Value wire_type, dbTechLayerRule* rule)
+      : dbRtEdge(VIA, wire_type, rule), _via(via)
+  {
+  }
+
+ public:
+  virtual void getBBox(Rect& bbox);
+
+  // Get the via of this edge
+  dbVia* getVia() const { return _via; }
+  void setVia(dbVia* via) { _via = via; }
+
+  friend class dbRtTree;
+};
+
+// TECH-VIA edge
+class dbRtTechVia : public dbRtEdge
+{
+  dbTechVia* _via;
+
+ public:
+  dbRtTechVia(dbTechVia* via,
+              dbWireType::Value wire_type,
+              dbTechLayerRule* rule)
+      : dbRtEdge(TECH_VIA, wire_type, rule), _via(via)
+  {
+  }
+
+ public:
+  virtual void getBBox(Rect& bbox);
+
+  // Get the via of this edge
+  dbTechVia* getVia() const { return _via; }
+
+  friend class dbRtTree;
+};
+
+// Wire segment
+class dbRtSegment : public dbRtEdge
+{
+  dbRtEndStyle _src_style;
+  dbRtEndStyle _tgt_style;
+
+  dbRtSegment(dbRtEndStyle src,
+              dbRtEndStyle tgt,
+              dbWireType::Value wire_type,
+              dbTechLayerRule* rule)
+      : dbRtEdge(SEGMENT, wire_type, rule), _src_style(src), _tgt_style(tgt)
+  {
+  }
+
+ public:
+  virtual void getBBox(Rect& bbox);
+
+  // Set the end-syle of the source node of this edge
+  void setSourceEndStyle(dbRtEndStyle style) { _src_style = style; }
+
+  // Get the end-syle of the source node of this edge
+  dbRtEndStyle getSourceEndStyle() const { return _src_style; }
+
+  // Set the end-syle of the target node of this edge
+  void setTargetEndStyle(dbRtEndStyle style) { _tgt_style = style; }
+
+  // Get the end-syle of the target node of this edge
+  dbRtEndStyle getTargetEndStyle() const { return _tgt_style; }
+
+  int getWidth() const;
+
+  friend class dbRtTree;
+};
+
+// Virtual short to node
+class dbRtShort : public dbRtEdge
+{
+  dbRtShort(dbWireType::Value wire_type, dbTechLayerRule* rule)
+      : dbRtEdge(SHORT, wire_type, rule)
+  {
+  }
+
+ public:
+  virtual void getBBox(Rect& bbox);
+
+  friend class dbRtTree;
+};
+
+// Virtual wire between nodes
+class dbRtVWire : public dbRtEdge
+{
+ public:
+  dbRtVWire(dbWireType::Value wire_type, dbTechLayerRule* rule)
+      : dbRtEdge(VWIRE, wire_type, rule)
+  {
+  }
+
+ public:
+  virtual void getBBox(Rect& bbox);
+
+  friend class dbRtTree;
+};
+
+}  // namespace odb

src/odb/include/odb/dbRtNode.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <vector>
+
+#include "dbRtEdge.h"
+#include "geom.h"
+#include "odb.h"
+#include "odbDList.h"
+
+namespace odb {
+
+class dbObject;
+class dbTechLayer;
+class dbRtTree;
+class dbRtEdge;
+class dbWireEncoder;
+
+class dbRtNodeEdgeIterator
+{
+  dbRtNode* _node;
+  dbRtEdge* _cur;
+
+  void incr() { _cur = _cur->next(_node); }
+
+ public:
+  dbRtNodeEdgeIterator()
+  {
+    _node = NULL;
+    _cur = NULL;
+  }
+  dbRtNodeEdgeIterator(dbRtNode* node, dbRtEdge* cur)
+  {
+    _node = node;
+    _cur = cur;
+  }
+  dbRtNodeEdgeIterator(const dbRtNodeEdgeIterator& i)
+  {
+    _node = i._node;
+    _cur = i._cur;
+  }
+  dbRtNodeEdgeIterator& operator=(const dbRtNodeEdgeIterator& i)
+  {
+    _node = i._node;
+    _cur = i._cur;
+    return *this;
+  }
+
+  bool operator==(const dbRtNodeEdgeIterator& i) const
+  {
+    return _cur == i._cur;
+  }
+  bool operator!=(const dbRtNodeEdgeIterator& i) const
+  {
+    return _cur != i._cur;
+  }
+  dbRtEdge* operator*() { return _cur; }
+  dbRtNodeEdgeIterator& operator++()
+  {
+    incr();
+    return *this;
+  }
+  dbRtNodeEdgeIterator operator++(int)
+  {
+    dbRtNodeEdgeIterator i = *this;
+    incr();
+    return i;
+  }
+};
+
+// Node - A Node represents a physical point in the graph.
+class dbRtNode
+{
+ private:
+  int _x;
+  int _y;
+  int _jct_id;
+  dbTechLayer* _layer;
+  std::vector<dbObject*> _objects;
+  dbRtTree* _rt_tree;
+  dbRtEdge* _head;
+  dbRtEdge* _tail;
+  DListEntry<dbRtNode> _rt_node;
+  bool _visited;
+
+  void add_edge(dbRtEdge* edge)
+  {
+    assert(edge->_src == this || edge->_tgt == this);
+
+    if (_head == NULL) {
+      _head = _tail = edge;
+      edge->next(this) = NULL;
+      edge->prev(this) = NULL;
+    } else {
+      edge->prev(this) = _tail;
+      _tail->next(this) = edge;
+      edge->next(this) = NULL;
+      _tail = edge;
+    }
+  }
+
+  void remove_edge(dbRtEdge* edge)
+  {
+    dbRtEdge* n = edge->next(this);
+    dbRtEdge* p = edge->prev(this);
+
+    if (p)
+      p->next(this) = n;
+    else
+      _head = n;
+
+    if (n)
+      n->prev(this) = p;
+    else
+      _tail = p;
+  }
+
+ public:
+  typedef dbRtNodeEdgeIterator edge_iterator;
+  typedef std::vector<dbObject*>::iterator object_iterator;
+
+  dbRtNode(int x, int y, dbTechLayer* layer)
+      : _x(x),
+        _y(y),
+        _jct_id(-1),
+        _layer(layer),
+        _rt_tree(NULL),
+        _head(NULL),
+        _tail(NULL),
+        _visited(false)
+  {
+  }
+
+  // Set the x/y location of this node
+  void setPoint(int x, int y)
+  {
+    _x = x;
+    _y = y;
+  }
+
+  // Set the x/y location of this node
+  void setPoint(Point& p)
+  {
+    _x = p.x();
+    _y = p.y();
+  }
+
+  // Set the x/y location of this node
+  void getPoint(int& x, int& y) const
+  {
+    x = _x;
+    y = _y;
+  }
+
+  // Set the x/y location of this node
+  void getPoint(Point& p) const { p = Point(_x, _y); }
+
+  // Get the x-coordinate of this point
+  int x() const { return _x; }
+
+  // Get the x-coordinate of this point
+  int y() const { return _y; }
+
+  // Set the layer of this node
+  void setLayer(dbTechLayer* layer) { _layer = layer; }
+
+  // Get the layer of this node
+  dbTechLayer* getLayer() const { return _layer; }
+
+  // begin iterating edges of this node
+  edge_iterator begin() { return edge_iterator(this, _head); }
+
+  // end iterating edges of this node
+  edge_iterator end() { return edge_iterator(this, NULL); }
+
+  // Add database object to this node
+  void addObject(dbObject* object) { _objects.push_back(object); }
+
+  // Get the database object assigned to this node
+  void getObjects(std::vector<dbObject*>& objects) const { objects = _objects; }
+
+  // Get the value of the visited flag.
+  bool isVisited() const { return _visited; }
+
+  // Set the value of the visited flag.
+  void setVisited(bool value) { _visited = value; }
+
+  // returns true if this node has no edges
+  bool isOrphan() const { return _head == NULL; }
+
+  // returns true if this node is not an orphan and has a single edge
+  bool isLeaf() const { return (_head != NULL) && (_head == _tail); }
+
+  object_iterator begin_objects() { return _objects.begin(); }
+  object_iterator end_objects() { return _objects.end(); }
+
+  static DListEntry<dbRtNode>* rtNode(dbRtNode* node)
+  {
+    return &node->_rt_node;
+  }
+
+  friend class dbRtTree;
+  friend class dbRtEdge;
+  friend class dbRtSegment;
+  friend class dbRtVia;
+  friend class dbRtTechVia;
+  friend class dbRtShort;
+  friend class dbRtVWire;
+};
+
+}  // namespace odb

src/odb/include/odb/dbRtTree.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <vector>
+
+#include "dbRtEdge.h"
+#include "dbRtNode.h"
+#include "dbTypes.h"
+#include "odb.h"
+#include "odbDList.h"
+
+namespace odb {
+
+class dbWire;
+class dbVia;
+class dbTechVia;
+class dbObject;
+class dbTechLayer;
+class dbTechLayerRule;
+class dbWireEncoder;
+
+class dbRtEdge;
+class dbRtNode;
+class dbRtSegment;
+class dbRtTechVia;
+class dbRtBlockVia;
+class dbRtShort;
+class dbRtVWire;
+
+//
+// dbRtTree - This class is used to represent an encoded dbWire as a graph.
+//
+//     The graph is undirected and cannot contain cycles.
+//
+//   Patch wires (rects) are not exposed in the tree.
+//
+class dbRtTree
+{
+ public:
+  dbRtTree();
+  ~dbRtTree();
+
+  // Clear this graph.
+  void clear();
+
+  // Decode a dbWire into this graph. Overwrites previous graph.
+  void decode(dbWire* wire, bool decode_bterm_iterms = true);
+
+  // Encode this graph into the dbWire. The contents of the dbWire are over
+  // written.
+  void encode(dbWire* wire, bool encode_bterm_iterms = true);
+
+  // Get the edge of this shape_id.
+  // PRECONDITION: The "target" node of this edge must exist (do not delete this
+  // node!).
+  dbRtEdge* getEdge(uint shape_id);
+
+  // Node Create Method
+  dbRtNode* createNode(int x, int y, dbTechLayer* l);
+
+  // Create a via edge.
+  //    Returns NULL, if the "tgt" node already has an in-edge.
+  //    Returns NULL, if the src and tgt layers are not the respective upper and
+  //    lower layers of this via.
+  dbRtVia* createVia(dbRtNode* src,
+                     dbRtNode* tgt,
+                     dbVia* via,
+                     dbWireType::Value type = dbWireType::NONE,
+                     dbTechLayerRule* rule = NULL);
+
+  // Create a tech-via edge.
+  //    Returns NULL, if the "tgt" node already has an in-edge.
+  //    Returns NULL, if the src and tgt layers are not the respective upper and
+  //    lower layers of this via.
+  dbRtTechVia* createTechVia(dbRtNode* src,
+                             dbRtNode* tgt,
+                             dbTechVia* via,
+                             dbWireType::Value type = dbWireType::NONE,
+                             dbTechLayerRule* rule = NULL);
+
+  // Create a segment edge with the default (EXTENDED) end style.
+  //    Returns NULL, if the "tgt" node already has an in-edge.
+  //    Returns NULL, if the src and tgt layer are not the same.
+  //    Returns NULL, if the src and tgt point do not form an orthogonal
+  //    segment.
+  dbRtSegment* createSegment(dbRtNode* src,
+                             dbRtNode* tgt,
+                             dbWireType::Value type = dbWireType::NONE,
+                             dbTechLayerRule* rule = NULL);
+
+  // Create a segment edge.
+  //    Returns NULL, if the "tgt" node already has an in-edge.
+  //    Returns NULL, if the src and tgt layer are not the same.
+  //    Returns NULL, if the src and tgt point do not form an orthogonal
+  //    segment.
+  dbRtSegment* createSegment(dbRtNode* src,
+                             dbRtNode* tgt,
+                             dbRtEndStyle src_style,
+                             dbRtEndStyle tgt_style,
+                             dbWireType::Value type = dbWireType::NONE,
+                             dbTechLayerRule* rule = NULL);
+
+  // Create a short edge.
+  //    Returns NULL, if the "tgt" node already has an in-edge.
+  dbRtShort* createShort(dbRtNode* src,
+                         dbRtNode* tgt,
+                         dbWireType::Value type = dbWireType::NONE,
+                         dbTechLayerRule* rule = NULL);
+
+  // Create a vwire edge.
+  //    Returns NULL, if the "tgt" node already has an in-edge.
+  dbRtVWire* createVWire(dbRtNode* src,
+                         dbRtNode* tgt,
+                         dbWireType::Value type = dbWireType::NONE,
+                         dbTechLayerRule* rule = NULL);
+
+  // Node iterator
+  typedef DList<dbRtNode, &dbRtNode::rtNode>::iterator node_iterator;
+
+  node_iterator begin_nodes() { return _nodes.begin(); }
+  node_iterator end_nodes() { return _nodes.end(); }
+
+  // Edge iterator
+  typedef DList<dbRtEdge, &dbRtEdge::rtEdge>::iterator edge_iterator;
+  edge_iterator begin_edges() { return _edges.begin(); }
+  edge_iterator end_edges() { return _edges.end(); }
+
+  // Delete the specified node
+  void deleteNode(dbRtNode* n);
+
+  // Delete the specified edge, does not delete orphan nodes
+  void deleteEdge(dbRtEdge* e);
+
+  // Delete the specified edge, does not delete orphan nodes
+  edge_iterator deleteEdge(edge_iterator itr)
+  {
+    dbRtEdge* e = *itr;
+    ++itr;
+    deleteEdge(e);
+    return itr;
+  }
+
+  // Delete the specified edge, optionally deletes orphan nodes
+  void deleteEdge(dbRtEdge* e, bool destroy_orphan_nodes);
+
+  // Delete the specified edge, optionally deletes orphan nodes
+  edge_iterator deleteEdge(edge_iterator itr, bool destroy_orphan_nodes)
+  {
+    dbRtEdge* e = *itr;
+    ++itr;
+    deleteEdge(e, destroy_orphan_nodes);
+    return itr;
+  }
+
+  // Make a copy of this graph
+  dbRtTree* duplicate();
+
+  // Move the tree "T" into this tree
+  // All the nodes/edges of "T" will be moved to this tree.
+  void move(dbRtTree* T);
+
+  // Copy the tree "T" into this tree
+  // All the nodes/edges of "T" will be copied to this tree.
+  void copy(dbRtTree* T);
+
+  // Make a duplicate copy of this node (does not duplicate edges) in the
+  // specified tree
+  static dbRtNode* duplicate(dbRtTree* G,
+                             dbRtNode* node,
+                             bool copy_objects = true);
+
+  // Make a duplicate copy of this edge between src and target in the specified
+  // tree
+  static dbRtEdge* duplicate(dbRtTree* G,
+                             dbRtEdge* edge,
+                             dbRtNode* src,
+                             dbRtNode* tgt);
+
+ private:
+  void encodePath(dbWireEncoder& encoder,
+                  std::vector<dbRtEdge*>& path,
+                  dbRtNode* src,
+                  dbWireType::Value cur_type,
+                  dbTechLayerRule* cur_rule,
+                  bool encode_bterms_iterms);
+  void encodePath(dbWireEncoder& encoder,
+                  std::vector<dbRtEdge*>& path,
+                  bool encode_bterms_iterms);
+  void add_node(dbRtNode* node);
+  void add_edge(dbRtEdge* edge);
+  void remove_node(dbRtNode* node);
+  void remove_edge(dbRtEdge* edge);
+  void addObjects(dbWireEncoder& encoder, dbRtNode* node);
+
+  static void copyNode(dbRtTree* G,
+                       dbRtNode* node,
+                       dbRtNode* src,
+                       bool copy_edge_map);
+  static void copyEdge(dbRtTree* G,
+                       dbRtNode* src,
+                       dbRtNode* tgt,
+                       dbRtEdge* edge,
+                       bool copy_edge_map);
+
+  std::vector<dbRtEdge*> _edge_map;
+  DList<dbRtNode, &dbRtNode::rtNode> _nodes;
+  DList<dbRtEdge, &dbRtEdge::rtEdge> _edges;
+};
+
+inline dbRtSegment* dbRtTree::createSegment(dbRtNode* src,
+                                            dbRtNode* tgt,
+                                            dbWireType::Value type,
+                                            dbTechLayerRule* rule)
+{
+  return createSegment(src, tgt, dbRtEndStyle(), dbRtEndStyle(), type, rule);
+}
+
+}  // namespace odb

src/odb/include/odb/dbSet.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "dbIterator.h"
+
+namespace odb {
+
+template <class T>
+class dbSet;
+
+template <class T>
+class dbSetIterator
+{
+  friend class dbSet<T>;
+
+  dbIterator* _itr;
+  uint _cur;
+
+  dbSetIterator(dbIterator* itr, uint id);
+
+ public:
+  typedef T* value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef T** pointer;
+  typedef T*& reference;
+  typedef std::input_iterator_tag iterator_category;
+
+  dbSetIterator();
+  dbSetIterator(const dbSetIterator& it) = default;
+
+  bool operator==(const dbSetIterator<T>& it);
+  bool operator!=(const dbSetIterator<T>& it);
+
+  T* operator*();
+  T* operator->();
+  dbSetIterator<T>& operator++();
+  dbSetIterator<T> operator++(int);
+};
+
+///
+/// The dbSet class provides an abstration of database objects collections.
+///
+/// There are two types of sets; sequential and non-sequential.
+///
+/// Sequential set iterators have the following property:
+///
+///     Let (o1,o2,o3,...,oN) be the objects iterated of a set, where 1..N
+///     represents the iteration order.
+///
+///     Then the following condition holds:
+///
+///        0 < o1->getId() < o2->getId() < o3->getId() < ... < oN->getId()
+///
+///     Because of object deletion, there may be gaps between the object
+///     identifiers in the iterated set:
+///
+///        Given: ... < oi->getId() < oj->getId() < ...
+///        Then: ... < (oi->getId() + 1) <= oj->getId() < ...
+///
+/// Non-Sequential set iterators do not have any ordering property.
+///
+template <class T>
+class dbSet
+{
+  dbIterator* _itr;
+  dbObject* _parent;
+
+ public:
+  typedef dbSetIterator<T> iterator;
+
+  dbSet()
+  {
+    _itr = NULL;
+    _parent = NULL;
+  }
+
+  dbSet(dbObject* parent, dbIterator* itr)
+  {
+    _parent = parent;
+    _itr = itr;
+  }
+
+  dbSet(const dbSet<T>& c)
+  {
+    _itr = c._itr;
+    _parent = c._parent;
+  }
+
+  ///
+  /// Returns the number of items in this set.
+  ///
+  uint size() { return _itr->size(_parent); }
+
+  ///
+  /// Return a begin() iterator.
+  ///
+  iterator begin() { return iterator(_itr, _itr->begin(_parent)); }
+
+  ///
+  /// Return an end() iterator.
+  ///
+  iterator end() { return iterator(_itr, _itr->end(_parent)); }
+
+  ///
+  /// If this set is sequential, this function will return the database
+  /// identifier of the "Nth" iterated element (see the class description
+  /// above):
+  ///
+  ///      returns oN->getId()
+  ///
+  /// If this set is non-sequential then it returns 0.
+  ///
+  uint sequential() { return _itr->sequential(); }
+
+  ///
+  /// Returns true if this set is 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(); }
+
+  ///
+  /// Reverse the order of this set.
+  ///
+  void reverse() { _itr->reverse(_parent); }
+
+  ///
+  /// Returns true if set is empty
+  ///
+  bool empty() { return begin() == end(); }
+};
+
+template <class T>
+inline dbSetIterator<T>::dbSetIterator()
+{
+  _itr = NULL;
+  _cur = 0;
+}
+
+template <class T>
+inline dbSetIterator<T>::dbSetIterator(dbIterator* itr, uint id)
+{
+  _itr = itr;
+  _cur = id;
+}
+
+template <class T>
+inline bool dbSetIterator<T>::operator==(const dbSetIterator& it)
+{
+  return (_itr == it._itr) && (_cur == it._cur);
+}
+
+template <class T>
+inline bool dbSetIterator<T>::operator!=(const dbSetIterator& it)
+{
+  return (_itr != it._itr) || (_cur != it._cur);
+}
+
+template <class T>
+inline T* dbSetIterator<T>::operator*()
+{
+  return (T*) _itr->getObject(_cur);
+}
+
+template <class T>
+inline T* dbSetIterator<T>::operator->()
+{
+  return (T*) _itr->getObject(_cur);
+}
+
+template <class T>
+inline dbSetIterator<T>& dbSetIterator<T>::operator++()
+{
+  _cur = _itr->next(_cur);
+  return *this;
+}
+
+template <class T>
+inline dbSetIterator<T> dbSetIterator<T>::operator++(int)
+{
+  dbSetIterator it(*this);
+  _cur = _itr->next(_cur);
+  return it;
+}
+
+}  // namespace odb
+
+// Specialization definitions
+#include "dbBlockSet.h"
+#include "dbCCSegSet.h"
+#include "dbNetSet.h"

src/odb/include/odb/dbStream.h

+///////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2019, Nefelus Inc
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <string.h>
+
+#include <array>
+#include <string>
+
+#include "ZException.h"
+#include "dbObject.h"
+#include "map"
+#include "odb.h"
+#include "tuple"
+
+namespace odb {
+
+class _dbDatabase;
+
+class dbOStream
+{
+  _dbDatabase* _db;
+  FILE* _f;
+  double _lef_area_factor;
+  double _lef_dist_factor;
+
+  void write_error()
+  {
+    throw ZException("write failed on database stream; system io error: (%s)",
+                     strerror(ferror(_f)));
+  }
+
+ public:
+  dbOStream(_dbDatabase* db, FILE* f);
+
+  _dbDatabase* getDatabase() { return _db; }
+
+  dbOStream& operator<<(bool c)
+  {
+    unsigned char b = (c == true ? 1 : 0);
+    return *this << b;
+  }
+
+  dbOStream& operator<<(char c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(unsigned char c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(short c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(unsigned short c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(int c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(uint64_t c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(unsigned int c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(int8_t c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(float c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(double c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(long double c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  dbOStream& operator<<(const char* c)
+  {
+    if (c == NULL) {
+      *this << 0;
+    } else {
+      int l = strlen(c) + 1;
+      *this << l;
+      int n = fwrite(c, l, 1, _f);
+      if (n != 1)
+        write_error();
+    }
+
+    return *this;
+  }
+
+  dbOStream& operator<<(dbObjectType c)
+  {
+    int n = fwrite(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      write_error();
+    return *this;
+  }
+
+  template <class T1, class T2>
+  dbOStream& operator<<(const std::pair<T1, T2>& p)
+  {
+    *this << p.first;
+    *this << p.second;
+    return *this;
+  }
+
+  template <size_t I = 0, typename... Ts>
+  constexpr dbOStream& operator<<(const std::tuple<Ts...>& tup)
+  {
+    if constexpr (I == sizeof...(Ts)) {
+      return *this;
+    } else {
+      *this << std::get<I>(tup);
+      return ((*this).operator<<<I + 1>(tup));
+    }
+  }
+
+  template <class T1, class T2>
+  dbOStream& operator<<(const std::map<T1, T2>& m)
+  {
+    uint sz = m.size();
+    *this << sz;
+    for (auto const& [key, val] : m) {
+      *this << key;
+      *this << val;
+    }
+    return *this;
+  }
+
+  template <class T, std::size_t SIZE>
+  dbOStream& operator<<(const std::array<T, SIZE>& a)
+  {
+    for (auto& val : a) {
+      *this << val;
+    }
+    return *this;
+  }
+
+  dbOStream& operator<<(std::string s)
+  {
+    char* tmp = strdup(s.c_str());
+    *this << tmp;
+    free((void*) tmp);
+    return *this;
+  }
+
+  void markStream()
+  {
+    int marker = ftell(_f);
+    int magic = 0xCCCCCCCC;
+    *this << magic;
+    *this << marker;
+  }
+
+  double lefarea(int value) { return ((double) value * _lef_area_factor); }
+
+  double lefdist(int value) { return ((double) value * _lef_dist_factor); }
+};
+
+class dbIStream
+{
+  FILE* _f;
+  _dbDatabase* _db;
+  double _lef_area_factor;
+  double _lef_dist_factor;
+
+  void read_error()
+  {
+    if (feof(_f))
+      throw ZException(
+          "read failed on database stream (unexpected end-of-file encounted).");
+    else
+      throw ZException("read failed on database stream; system io error: (%s)",
+                       strerror(ferror(_f)));
+  }
+
+ public:
+  dbIStream(_dbDatabase* db, FILE* f);
+
+  _dbDatabase* getDatabase() { return _db; }
+
+  dbIStream& operator>>(bool& c)
+  {
+    unsigned char b;
+    *this >> b;
+    c = (b == 1 ? true : false);
+    return *this;
+  }
+
+  dbIStream& operator>>(char& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(unsigned char& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(short& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(unsigned short& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(int& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(uint64_t& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(unsigned int& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(int8_t& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(float& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(double& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(long double& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  dbIStream& operator>>(char*& c)
+  {
+    int l;
+    *this >> l;
+
+    if (l == 0)
+      c = NULL;
+    else {
+      c = (char*) malloc(l);
+      int n = fread(c, l, 1, _f);
+      if (n != 1)
+        read_error();
+    }
+
+    return *this;
+  }
+
+  dbIStream& operator>>(dbObjectType& c)
+  {
+    int n = fread(&c, sizeof(c), 1, _f);
+    if (n != 1)
+      read_error();
+    return *this;
+  }
+
+  template <class T1, class T2>
+  dbIStream& operator>>(std::pair<T1, T2>& p)
+  {
+    *this >> p.first;
+    *this >> p.second;
+    return *this;
+  }
+  template <class T1, class T2>
+  dbIStream& operator>>(std::map<T1, T2>& m)
+  {
+    uint sz;
+    *this >> sz;
+    for (uint i = 0; i < sz; i++) {
+      T1 key;
+      T2 val;
+      *this >> key;
+      *this >> val;
+      m[key] = val;
+    }
+    return *this;
+  }
+  template <class T, std::size_t SIZE>
+  dbIStream& operator>>(std::array<T, SIZE>& a)
+  {
+    for (std::size_t i = 0; i < SIZE; i++) {
+      *this >> a[i];
+    }
+    return *this;
+  }
+
+  template <size_t I = 0, typename... Ts>
+  constexpr dbIStream& operator>>(std::tuple<Ts...>& tup)
+  {
+    if constexpr (I == sizeof...(Ts)) {
+      return *this;
+    } else {
+      *this >> std::get<I>(tup);
+      return ((*this).operator>><I + 1>(tup));
+    }
+  }
+
+  dbIStream& operator>>(std::string& s)
+  {
+    char* tmp;
+    *this >> tmp;
+    s = std::string(tmp);
+    free((void*) tmp);
+    return *this;
+  }
+
+  void checkStream()
+  {
+    int marker = ftell(_f);
+    int magic = 0xCCCCCCCC;
+    int smarker;
+    int smagic;
+    *this >> smagic;
+    *this >> smarker;
+    ZASSERT((magic == smagic) && (marker == smarker));
+  }
+
+  double lefarea(int value) { return ((double) value * _lef_area_factor); }
+
+  double lefdist(int value) { return ((double) value * _lef_dist_factor); }
+};
+
+}  // namespace odb