opendbpy for reference

opendbpy.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _odb_py
else:
    import _odb_py

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _odb_py.delete_SwigPyIterator

    def value(self):
        return _odb_py.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _odb_py.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _odb_py.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _odb_py.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _odb_py.SwigPyIterator_equal(self, x)

    def copy(self):
        return _odb_py.SwigPyIterator_copy(self)

    def next(self):
        return _odb_py.SwigPyIterator_next(self)

    def __next__(self):
        return _odb_py.SwigPyIterator___next__(self)

    def previous(self):
        return _odb_py.SwigPyIterator_previous(self)

    def advance(self, n):
        return _odb_py.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _odb_py.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _odb_py.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _odb_py.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _odb_py.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _odb_py.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _odb_py.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _odb_py:
_odb_py.SwigPyIterator_swigregister(SwigPyIterator)

class vector_str(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _odb_py.vector_str_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _odb_py.vector_str___nonzero__(self)

    def __bool__(self):
        return _odb_py.vector_str___bool__(self)

    def __len__(self):
        return _odb_py.vector_str___len__(self)

    def __getslice__(self, i, j):
        return _odb_py.vector_str___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _odb_py.vector_str___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _odb_py.vector_str___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _odb_py.vector_str___delitem__(self, *args)

    def __getitem__(self, *args):
        return _odb_py.vector_str___getitem__(self, *args)

    def __setitem__(self, *args):
        return _odb_py.vector_str___setitem__(self, *args)

    def pop(self):
        return _odb_py.vector_str_pop(self)

    def append(self, x):
        return _odb_py.vector_str_append(self, x)

    def empty(self):
        return _odb_py.vector_str_empty(self)

    def size(self):
        return _odb_py.vector_str_size(self)

    def swap(self, v):
        return _odb_py.vector_str_swap(self, v)

    def begin(self):
        return _odb_py.vector_str_begin(self)

    def end(self):
        return _odb_py.vector_str_end(self)

    def rbegin(self):
        return _odb_py.vector_str_rbegin(self)

    def rend(self):
        return _odb_py.vector_str_rend(self)

    def clear(self):
        return _odb_py.vector_str_clear(self)

    def get_allocator(self):
        return _odb_py.vector_str_get_allocator(self)

    def pop_back(self):
        return _odb_py.vector_str_pop_back(self)

    def erase(self, *args):
        return _odb_py.vector_str_erase(self, *args)

    def __init__(self, *args):
        _odb_py.vector_str_swiginit(self, _odb_py.new_vector_str(*args))

    def push_back(self, x):
        return _odb_py.vector_str_push_back(self, x)

    def front(self):
        return _odb_py.vector_str_front(self)

    def back(self):
        return _odb_py.vector_str_back(self)

    def assign(self, n, x):
        return _odb_py.vector_str_assign(self, n, x)

    def resize(self, *args):
        return _odb_py.vector_str_resize(self, *args)

    def insert(self, *args):
        return _odb_py.vector_str_insert(self, *args)

    def reserve(self, n):
        return _odb_py.vector_str_reserve(self, n)

    def capacity(self):
        return _odb_py.vector_str_capacity(self)
    __swig_destroy__ = _odb_py.delete_vector_str

# Register vector_str in _odb_py:
_odb_py.vector_str_swigregister(vector_str)

class Point(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _odb_py.Point_swiginit(self, _odb_py.new_Point(*args))
    __swig_destroy__ = _odb_py.delete_Point

    def assign(self, rhs):
        return _odb_py.Point_assign(self, rhs)

    def __eq__(self, rhs):
        return _odb_py.Point___eq__(self, rhs)

    def __ne__(self, rhs):
        return _odb_py.Point___ne__(self, rhs)

    def __lt__(self, rhs):
        return _odb_py.Point___lt__(self, rhs)

    def __ge__(self, rhs):
        return _odb_py.Point___ge__(self, rhs)

    def getX(self):
        return _odb_py.Point_getX(self)

    def getY(self):
        return _odb_py.Point_getY(self)

    def setX(self, x):
        return _odb_py.Point_setX(self, x)

    def setY(self, y):
        return _odb_py.Point_setY(self, y)

    def addX(self, x):
        return _odb_py.Point_addX(self, x)

    def addY(self, y):
        return _odb_py.Point_addY(self, y)

    def rotate90(self):
        return _odb_py.Point_rotate90(self)

    def rotate180(self):
        return _odb_py.Point_rotate180(self)

    def rotate270(self):
        return _odb_py.Point_rotate270(self)

    def x(self):
        return _odb_py.Point_x(self)

    def y(self):
        return _odb_py.Point_y(self)

    @staticmethod
    def squaredDistance(p0, p1):
        return _odb_py.Point_squaredDistance(p0, p1)

    @staticmethod
    def manhattanDistance(p0, p1):
        return _odb_py.Point_manhattanDistance(p0, p1)

# Register Point in _odb_py:
_odb_py.Point_swigregister(Point)

def Point_squaredDistance(p0, p1):
    return _odb_py.Point_squaredDistance(p0, p1)

def Point_manhattanDistance(p0, p1):
    return _odb_py.Point_manhattanDistance(p0, p1)

class Oct(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    RIGHT = _odb_py.Oct_RIGHT
    LEFT = _odb_py.Oct_LEFT
    UNKNOWN = _odb_py.Oct_UNKNOWN

    def __init__(self, *args):
        _odb_py.Oct_swiginit(self, _odb_py.new_Oct(*args))
    __swig_destroy__ = _odb_py.delete_Oct

    def assign(self, r):
        return _odb_py.Oct_assign(self, r)

    def __eq__(self, r):
        return _odb_py.Oct___eq__(self, r)

    def __ne__(self, r):
        return _odb_py.Oct___ne__(self, r)

    def init(self, p1, p2, width):
        return _odb_py.Oct_init(self, p1, p2, width)

    def getDir(self):
        return _odb_py.Oct_getDir(self)

    def getCenterHigh(self):
        return _odb_py.Oct_getCenterHigh(self)

    def getCenterLow(self):
        return _odb_py.Oct_getCenterLow(self)

    def getWidth(self):
        return _odb_py.Oct_getWidth(self)

    def dx(self):
        return _odb_py.Oct_dx(self)

    def dy(self):
        return _odb_py.Oct_dy(self)

    def xMin(self):
        return _odb_py.Oct_xMin(self)

    def yMin(self):
        return _odb_py.Oct_yMin(self)

    def xMax(self):
        return _odb_py.Oct_xMax(self)

    def yMax(self):
        return _odb_py.Oct_yMax(self)

    def getPoints(self):
        return _odb_py.Oct_getPoints(self)

# Register Oct in _odb_py:
_odb_py.Oct_swigregister(Oct)

class Rect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _odb_py.Rect_swiginit(self, _odb_py.new_Rect(*args))

    def assign(self):
        return _odb_py.Rect_assign(self)

    def __eq__(self):
        return _odb_py.Rect___eq__(self)

    def __ne__(self):
        return _odb_py.Rect___ne__(self)

    def __lt__(self):
        return _odb_py.Rect___lt__(self)

    def __gt__(self):
        return _odb_py.Rect___gt__(self)

    def __le__(self):
        return _odb_py.Rect___le__(self)

    def __ge__(self):
        return _odb_py.Rect___ge__(self)

    def init(self, x1, y1, x2, y2):
        return _odb_py.Rect_init(self, x1, y1, x2, y2)

    def reset(self, x1, y1, x2, y2):
        return _odb_py.Rect_reset(self, x1, y1, x2, y2)

    def moveTo(self, x, y):
        return _odb_py.Rect_moveTo(self, x, y)

    def moveDelta(self, dx, dy):
        return _odb_py.Rect_moveDelta(self, dx, dy)

    def mergeInit(self):
        return _odb_py.Rect_mergeInit(self)

    def isInverted(self):
        return _odb_py.Rect_isInverted(self)

    def minDXDY(self):
        return _odb_py.Rect_minDXDY(self)

    def maxDXDY(self):
        return _odb_py.Rect_maxDXDY(self)

    def getDir(self):
        return _odb_py.Rect_getDir(self)

    def set_xlo(self, x):
        return _odb_py.Rect_set_xlo(self, x)

    def set_xhi(self, x):
        return _odb_py.Rect_set_xhi(self, x)

    def set_ylo(self, y):
        return _odb_py.Rect_set_ylo(self, y)

    def set_yhi(self, y):
        return _odb_py.Rect_set_yhi(self, y)

    def xMin(self):
        return _odb_py.Rect_xMin(self)

    def yMin(self):
        return _odb_py.Rect_yMin(self)

    def xMax(self):
        return _odb_py.Rect_xMax(self)

    def yMax(self):
        return _odb_py.Rect_yMax(self)

    def dx(self):
        return _odb_py.Rect_dx(self)

    def dy(self):
        return _odb_py.Rect_dy(self)

    def xCenter(self):
        return _odb_py.Rect_xCenter(self)

    def yCenter(self):
        return _odb_py.Rect_yCenter(self)

    def getPoints(self):
        return _odb_py.Rect_getPoints(self)

    def ll(self):
        return _odb_py.Rect_ll(self)

    def ul(self):
        return _odb_py.Rect_ul(self)

    def ur(self):
        return _odb_py.Rect_ur(self)

    def lr(self):
        return _odb_py.Rect_lr(self)

    def intersects(self, *args):
        return _odb_py.Rect_intersects(self, *args)

    def overlaps(self, *args):
        return _odb_py.Rect_overlaps(self, *args)

    def contains(self):
        return _odb_py.Rect_contains(self)

    def inside(self):
        return _odb_py.Rect_inside(self)

    def closestPtInside(self, pt):
        return _odb_py.Rect_closestPtInside(self, pt)

    def merge(self, *args):
        return _odb_py.Rect_merge(self, *args)

    def bloat(self, margin, result):
        return _odb_py.Rect_bloat(self, margin, result)

    def intersection(self, result):
        return _odb_py.Rect_intersection(self, result)

    def intersect(self):
        return _odb_py.Rect_intersect(self)

    def area(self):
        return _odb_py.Rect_area(self)

    def margin(self):
        return _odb_py.Rect_margin(self)

    def printf(self, *args):
        return _odb_py.Rect_printf(self, *args)

    def _print(self, *args):
        return _odb_py.Rect__print(self, *args)
    __swig_destroy__ = _odb_py.delete_Rect

# Register Rect in _odb_py:
_odb_py.Rect_swigregister(Rect)

class Points(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _odb_py.Points_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _odb_py.Points___nonzero__(self)

    def __bool__(self):
        return _odb_py.Points___bool__(self)

    def __len__(self):
        return _odb_py.Points___len__(self)

    def __getslice__(self, i, j):
        return _odb_py.Points___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _odb_py.Points___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _odb_py.Points___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _odb_py.Points___delitem__(self, *args)

    def __getitem__(self, *args):
        return _odb_py.Points___getitem__(self, *args)

    def __setitem__(self, *args):
        return _odb_py.Points___setitem__(self, *args)

    def pop(self):
        return _odb_py.Points_pop(self)

    def append(self, x):
        return _odb_py.Points_append(self, x)

    def empty(self):
        return _odb_py.Points_empty(self)

    def size(self):
        return _odb_py.Points_size(self)

    def swap(self, v):
        return _odb_py.Points_swap(self, v)

    def begin(self):
        return _odb_py.Points_begin(self)

    def end(self):
        return _odb_py.Points_end(self)

    def rbegin(self):
        return _odb_py.Points_rbegin(self)

    def rend(self):
        return _odb_py.Points_rend(self)

    def clear(self):
        return _odb_py.Points_clear(self)

    def get_allocator(self):
        return _odb_py.Points_get_allocator(self)

    def pop_back(self):
        return _odb_py.Points_pop_back(self)

    def erase(self, *args):
        return _odb_py.Points_erase(self, *args)

    def __init__(self, *args):
        _odb_py.Points_swiginit(self, _odb_py.new_Points(*args))

    def push_back(self, x):
        return _odb_py.Points_push_back(self, x)

    def front(self):
        return _odb_py.Points_front(self)

    def back(self):
        return _odb_py.Points_back(self)

    def assign(self, n, x):
        return _odb_py.Points_assign(self, n, x)

    def resize(self, *args):
        return _odb_py.Points_resize(self, *args)

    def insert(self, *args):
        return _odb_py.Points_insert(self, *args)

    def reserve(self, n):
        return _odb_py.Points_reserve(self, n)

    def capacity(self):
        return _odb_py.Points_capacity(self)
    __swig_destroy__ = _odb_py.delete_Points

# Register Points in _odb_py:
_odb_py.Points_swigregister(Points)

class Rects(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _odb_py.Rects_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _odb_py.Rects___nonzero__(self)

    def __bool__(self):
        return _odb_py.Rects___bool__(self)

    def __len__(self):
        return _odb_py.Rects___len__(self)

    def __getslice__(self, i, j):
        return _odb_py.Rects___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _odb_py.Rects___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _odb_py.Rects___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _odb_py.Rects___delitem__(self, *args)

    def __getitem__(self, *args):
        return _odb_py.Rects___getitem__(self, *args)

    def __setitem__(self, *args):
        return _odb_py.Rects___setitem__(self, *args)

    def pop(self):
        return _odb_py.Rects_pop(self)

    def append(self, x):
        return _odb_py.Rects_append(self, x)

    def empty(self):
        return _odb_py.Rects_empty(self)

    def size(self):
        return _odb_py.Rects_size(self)

    def swap(self, v):
        return _odb_py.Rects_swap(self, v)

    def begin(self):
        return _odb_py.Rects_begin(self)

    def end(self):
        return _odb_py.Rects_end(self)

    def rbegin(self):
        return _odb_py.Rects_rbegin(self)

    def rend(self):
        return _odb_py.Rects_rend(self)

    def clear(self):
        return _odb_py.Rects_clear(self)

    def get_allocator(self):
        return _odb_py.Rects_get_allocator(self)

    def pop_back(self):
        return _odb_py.Rects_pop_back(self)

    def erase(self, *args):
        return _odb_py.Rects_erase(self, *args)

    def __init__(self, *args):
        _odb_py.Rects_swiginit(self, _odb_py.new_Rects(*args))

    def push_back(self, x):
        return _odb_py.Rects_push_back(self, x)

    def front(self):
        return _odb_py.Rects_front(self)

    def back(self):
        return _odb_py.Rects_back(self)

    def assign(self, n, x):
        return _odb_py.Rects_assign(self, n, x)

    def resize(self, *args):
        return _odb_py.Rects_resize(self, *args)

    def insert(self, *args):
        return _odb_py.Rects_insert(self, *args)

    def reserve(self, n):
        return _odb_py.Rects_reserve(self, n)

    def capacity(self):
        return _odb_py.Rects_capacity(self)
    __swig_destroy__ = _odb_py.delete_Rects

# Register Rects in _odb_py:
_odb_py.Rects_swigregister(Rects)

class Polygon90Set(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _odb_py.Polygon90Set_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _odb_py.Polygon90Set___nonzero__(self)

    def __bool__(self):
        return _odb_py.Polygon90Set___bool__(self)

    def __len__(self):
        return _odb_py.Polygon90Set___len__(self)

    def __getslice__(self, i, j):
        return _odb_py.Polygon90Set___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _odb_py.Polygon90Set___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _odb_py.Polygon90Set___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _odb_py.Polygon90Set___delitem__(self, *args)

    def __getitem__(self, *args):
        return _odb_py.Polygon90Set___getitem__(self, *args)

    def __setitem__(self, *args):
        return _odb_py.Polygon90Set___setitem__(self, *args)

    def pop(self):
        return _odb_py.Polygon90Set_pop(self)

    def append(self, x):
        return _odb_py.Polygon90Set_append(self, x)

    def empty(self):
        return _odb_py.Polygon90Set_empty(self)

    def size(self):
        return _odb_py.Polygon90Set_size(self)

    def swap(self, v):
        return _odb_py.Polygon90Set_swap(self, v)

    def begin(self):
        return _odb_py.Polygon90Set_begin(self)

    def end(self):
        return _odb_py.Polygon90Set_end(self)

    def rbegin(self):
        return _odb_py.Polygon90Set_rbegin(self)

    def rend(self):
        return _odb_py.Polygon90Set_rend(self)

    def clear(self):
        return _odb_py.Polygon90Set_clear(self)

    def get_allocator(self):
        return _odb_py.Polygon90Set_get_allocator(self)

    def pop_back(self):
        return _odb_py.Polygon90Set_pop_back(self)

    def erase(self, *args):
        return _odb_py.Polygon90Set_erase(self, *args)

    def __init__(self, *args):
        _odb_py.Polygon90Set_swiginit(self, _odb_py.new_Polygon90Set(*args))

    def push_back(self, x):
        return _odb_py.Polygon90Set_push_back(self, x)

    def front(self):
        return _odb_py.Polygon90Set_front(self)

    def back(self):
        return _odb_py.Polygon90Set_back(self)

    def assign(self, n, x):
        return _odb_py.Polygon90Set_assign(self, n, x)

    def resize(self, *args):
        return _odb_py.Polygon90Set_resize(self, *args)

    def insert(self, *args):
        return _odb_py.Polygon90Set_insert(self, *args)

    def reserve(self, n):
        return _odb_py.Polygon90Set_reserve(self, n)

    def capacity(self):
        return _odb_py.Polygon90Set_capacity(self)
    __swig_destroy__ = _odb_py.delete_Polygon90Set

# Register Polygon90Set in _odb_py:
_odb_py.Polygon90Set_swigregister(Polygon90Set)

class Polygon90Sets(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _odb_py.Polygon90Sets_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _odb_py.Polygon90Sets___nonzero__(self)

    def __bool__(self):
        return _odb_py.Polygon90Sets___bool__(self)

    def __len__(self):
        return _odb_py.Polygon90Sets___len__(self)

    def __getslice__(self, i, j):
        return _odb_py.Polygon90Sets___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _odb_py.Polygon90Sets___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _odb_py.Polygon90Sets___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _odb_py.Polygon90Sets___delitem__(self, *args)

    def __getitem__(self, *args):
        return _odb_py.Polygon90Sets___getitem__(self, *args)

    def __setitem__(self, *args):
        return _odb_py.Polygon90Sets___setitem__(self, *args)

    def pop(self):
        return _odb_py.Polygon90Sets_pop(self)

    def append(self, x):
        return _odb_py.Polygon90Sets_append(self, x)

    def empty(self):
        return _odb_py.Polygon90Sets_empty(self)

    def size(self):
        return _odb_py.Polygon90Sets_size(self)

    def swap(self, v):
        return _odb_py.Polygon90Sets_swap(self, v)

    def begin(self):
        return _odb_py.Polygon90Sets_begin(self)

    def end(self):
        return _odb_py.Polygon90Sets_end(self)

    def rbegin(self):
        return _odb_py.Polygon90Sets_rbegin(self)

    def rend(self):
        return _odb_py.Polygon90Sets_rend(self)

    def clear(self):
        return _odb_py.Polygon90Sets_clear(self)

    def get_allocator(self):
        return _odb_py.Polygon90Sets_get_allocator(self)

    def pop_back(self):
        return _odb_py.Polygon90Sets_pop_back(self)

    def erase(self, *args):
        return _odb_py.Polygon90Sets_erase(self, *args)

    def __init__(self, *args):
        _odb_py.Polygon90Sets_swiginit(self, _odb_py.new_Polygon90Sets(*args))

    def push_back(self, x):
        return _odb_py.Polygon90Sets_push_back(self, x)

    def front(self):
        return _odb_py.Polygon90Sets_front(self)

    def back(self):
        return _odb_py.Polygon90Sets_back(self)

    def assign(self, n, x):
        return _odb_py.Polygon90Sets_assign(self, n, x)

    def resize(self, *args):
        return _odb_py.Polygon90Sets_resize(self, *args)

    def insert(self, *args):
        return _odb_py.Polygon90Sets_insert(self, *args)

    def reserve(self, n):
        return _odb_py.Polygon90Sets_reserve(self, n)

    def capacity(self):
        return _odb_py.Polygon90Sets_capacity(self)
    __swig_destroy__ = _odb_py.delete_Polygon90Sets

# Register Polygon90Sets in _odb_py:
_odb_py.Polygon90Sets_swigregister(Polygon90Sets)


def newSetFromRect(xLo, yLo, xHi, yHi):
    return _odb_py.newSetFromRect(xLo, yLo, xHi, yHi)

def getPoints(polygon):
    return _odb_py.getPoints(polygon)

def getPolygons(set):
    return _odb_py.getPolygons(set)

def getRectangles(set):
    return _odb_py.getRectangles(set)

def bloatSet(*args):
    return _odb_py.bloatSet(*args)

def shrinkSet(*args):
    return _odb_py.shrinkSet(*args)

def andSet(set1, set2):
    return _odb_py.andSet(set1, set2)

def orSet(set1, set2):
    return _odb_py.orSet(set1, set2)

def orSets(sets):
    return _odb_py.orSets(sets)

def subtractSet(set1, set2):
    return _odb_py.subtractSet(set1, set2)
ADS_MAX_CORNER = _odb_py.ADS_MAX_CORNER
class dbProperty(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    STRING_PROP = _odb_py.dbProperty_STRING_PROP
    BOOL_PROP = _odb_py.dbProperty_BOOL_PROP
    INT_PROP = _odb_py.dbProperty_INT_PROP
    DOUBLE_PROP = _odb_py.dbProperty_DOUBLE_PROP

    def getType(self):
        return _odb_py.dbProperty_getType(self)

    def getName(self):
        return _odb_py.dbProperty_getName(self)

    def getPropOwner(self):
        return _odb_py.dbProperty_getPropOwner(self)

    @staticmethod
    def find(*args):
        return _odb_py.dbProperty_find(*args)

    @staticmethod
    def destroyProperties(obj):
        return _odb_py.dbProperty_destroyProperties(obj)

    @staticmethod
    def getProperties(object):
        return _odb_py.dbProperty_getProperties(object)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbProperty_destroy(*args)

    @staticmethod
    def writeProperties(object):
        return _odb_py.dbProperty_writeProperties(object)

    @staticmethod
    def writePropValue(prop):
        return _odb_py.dbProperty_writePropValue(prop)

    def __init__(self):
        _odb_py.dbProperty_swiginit(self, _odb_py.new_dbProperty())
    __swig_destroy__ = _odb_py.delete_dbProperty

# Register dbProperty in _odb_py:
_odb_py.dbProperty_swigregister(dbProperty)

def dbProperty_find(*args):
    return _odb_py.dbProperty_find(*args)

def dbProperty_destroyProperties(obj):
    return _odb_py.dbProperty_destroyProperties(obj)

def dbProperty_getProperties(object):
    return _odb_py.dbProperty_getProperties(object)

def dbProperty_destroy(*args):
    return _odb_py.dbProperty_destroy(*args)

def dbProperty_writeProperties(object):
    return _odb_py.dbProperty_writeProperties(object)

def dbProperty_writePropValue(prop):
    return _odb_py.dbProperty_writePropValue(prop)

class dbBoolProperty(dbProperty):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getValue(self):
        return _odb_py.dbBoolProperty_getValue(self)

    def setValue(self, value):
        return _odb_py.dbBoolProperty_setValue(self, value)

    @staticmethod
    def create(object, name, value):
        return _odb_py.dbBoolProperty_create(object, name, value)

    @staticmethod
    def find(object, name):
        return _odb_py.dbBoolProperty_find(object, name)

    def __init__(self):
        _odb_py.dbBoolProperty_swiginit(self, _odb_py.new_dbBoolProperty())
    __swig_destroy__ = _odb_py.delete_dbBoolProperty

# Register dbBoolProperty in _odb_py:
_odb_py.dbBoolProperty_swigregister(dbBoolProperty)

def dbBoolProperty_create(object, name, value):
    return _odb_py.dbBoolProperty_create(object, name, value)

def dbBoolProperty_find(object, name):
    return _odb_py.dbBoolProperty_find(object, name)

class dbStringProperty(dbProperty):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getValue(self):
        return _odb_py.dbStringProperty_getValue(self)

    def setValue(self, value):
        return _odb_py.dbStringProperty_setValue(self, value)

    @staticmethod
    def create(object, name, value):
        return _odb_py.dbStringProperty_create(object, name, value)

    @staticmethod
    def find(object, name):
        return _odb_py.dbStringProperty_find(object, name)

    def __init__(self):
        _odb_py.dbStringProperty_swiginit(self, _odb_py.new_dbStringProperty())
    __swig_destroy__ = _odb_py.delete_dbStringProperty

# Register dbStringProperty in _odb_py:
_odb_py.dbStringProperty_swigregister(dbStringProperty)

def dbStringProperty_create(object, name, value):
    return _odb_py.dbStringProperty_create(object, name, value)

def dbStringProperty_find(object, name):
    return _odb_py.dbStringProperty_find(object, name)

class dbIntProperty(dbProperty):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getValue(self):
        return _odb_py.dbIntProperty_getValue(self)

    def setValue(self, value):
        return _odb_py.dbIntProperty_setValue(self, value)

    @staticmethod
    def create(object, name, value):
        return _odb_py.dbIntProperty_create(object, name, value)

    @staticmethod
    def find(object, name):
        return _odb_py.dbIntProperty_find(object, name)

    def __init__(self):
        _odb_py.dbIntProperty_swiginit(self, _odb_py.new_dbIntProperty())
    __swig_destroy__ = _odb_py.delete_dbIntProperty

# Register dbIntProperty in _odb_py:
_odb_py.dbIntProperty_swigregister(dbIntProperty)

def dbIntProperty_create(object, name, value):
    return _odb_py.dbIntProperty_create(object, name, value)

def dbIntProperty_find(object, name):
    return _odb_py.dbIntProperty_find(object, name)

class dbDoubleProperty(dbProperty):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getValue(self):
        return _odb_py.dbDoubleProperty_getValue(self)

    def setValue(self, value):
        return _odb_py.dbDoubleProperty_setValue(self, value)

    @staticmethod
    def create(object, name, value):
        return _odb_py.dbDoubleProperty_create(object, name, value)

    @staticmethod
    def find(object, name):
        return _odb_py.dbDoubleProperty_find(object, name)

    def __init__(self):
        _odb_py.dbDoubleProperty_swiginit(self, _odb_py.new_dbDoubleProperty())
    __swig_destroy__ = _odb_py.delete_dbDoubleProperty

# Register dbDoubleProperty in _odb_py:
_odb_py.dbDoubleProperty_swigregister(dbDoubleProperty)

def dbDoubleProperty_create(object, name, value):
    return _odb_py.dbDoubleProperty_create(object, name, value)

def dbDoubleProperty_find(object, name):
    return _odb_py.dbDoubleProperty_find(object, name)

class dbDatabase(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getLibs(self):
        return _odb_py.dbDatabase_getLibs(self)

    def findLib(self, name):
        return _odb_py.dbDatabase_findLib(self, name)

    def getTechs(self):
        return _odb_py.dbDatabase_getTechs(self)

    def findTech(self, name):
        return _odb_py.dbDatabase_findTech(self, name)

    def findMaster(self, name):
        return _odb_py.dbDatabase_findMaster(self, name)

    def getChip(self):
        return _odb_py.dbDatabase_getChip(self)

    def getTech(self):
        return _odb_py.dbDatabase_getTech(self)

    def getChips(self):
        return _odb_py.dbDatabase_getChips(self)

    def getNumberOfMasters(self):
        return _odb_py.dbDatabase_getNumberOfMasters(self)

    def read(self, f):
        return _odb_py.dbDatabase_read(self, f)

    def write(self, file):
        return _odb_py.dbDatabase_write(self, file)

    @staticmethod
    def beginEco(block):
        return _odb_py.dbDatabase_beginEco(block)

    @staticmethod
    def endEco(block):
        return _odb_py.dbDatabase_endEco(block)

    @staticmethod
    def ecoEmpty(block):
        return _odb_py.dbDatabase_ecoEmpty(block)

    @staticmethod
    def readEco(block, filename):
        return _odb_py.dbDatabase_readEco(block, filename)

    @staticmethod
    def writeEco(block, filename):
        return _odb_py.dbDatabase_writeEco(block, filename)

    @staticmethod
    def checkEco(block):
        return _odb_py.dbDatabase_checkEco(block)

    @staticmethod
    def commitEco(block):
        return _odb_py.dbDatabase_commitEco(block)

    def setLogger(self, logger):
        return _odb_py.dbDatabase_setLogger(self, logger)

    def clear(self):
        return _odb_py.dbDatabase_clear(self)

    @staticmethod
    def create():
        return _odb_py.dbDatabase_create()

    @staticmethod
    def destroy(db):
        return _odb_py.dbDatabase_destroy(db)

    @staticmethod
    def duplicate(db):
        return _odb_py.dbDatabase_duplicate(db)

    @staticmethod
    def diff(db0, db1, file, indent_per_level):
        return _odb_py.dbDatabase_diff(db0, db1, file, indent_per_level)

    @staticmethod
    def getDatabase(oid):
        return _odb_py.dbDatabase_getDatabase(oid)

    def __init__(self):
        _odb_py.dbDatabase_swiginit(self, _odb_py.new_dbDatabase())
    __swig_destroy__ = _odb_py.delete_dbDatabase

# Register dbDatabase in _odb_py:
_odb_py.dbDatabase_swigregister(dbDatabase)

def dbDatabase_beginEco(block):
    return _odb_py.dbDatabase_beginEco(block)

def dbDatabase_endEco(block):
    return _odb_py.dbDatabase_endEco(block)

def dbDatabase_ecoEmpty(block):
    return _odb_py.dbDatabase_ecoEmpty(block)

def dbDatabase_readEco(block, filename):
    return _odb_py.dbDatabase_readEco(block, filename)

def dbDatabase_writeEco(block, filename):
    return _odb_py.dbDatabase_writeEco(block, filename)

def dbDatabase_checkEco(block):
    return _odb_py.dbDatabase_checkEco(block)

def dbDatabase_commitEco(block):
    return _odb_py.dbDatabase_commitEco(block)

def dbDatabase_create():
    return _odb_py.dbDatabase_create()

def dbDatabase_destroy(db):
    return _odb_py.dbDatabase_destroy(db)

def dbDatabase_duplicate(db):
    return _odb_py.dbDatabase_duplicate(db)

def dbDatabase_diff(db0, db1, file, indent_per_level):
    return _odb_py.dbDatabase_diff(db0, db1, file, indent_per_level)

def dbDatabase_getDatabase(oid):
    return _odb_py.dbDatabase_getDatabase(oid)

class dbBox(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def xMin(self):
        return _odb_py.dbBox_xMin(self)

    def yMin(self):
        return _odb_py.dbBox_yMin(self)

    def xMax(self):
        return _odb_py.dbBox_xMax(self)

    def yMax(self):
        return _odb_py.dbBox_yMax(self)

    def isVia(self):
        return _odb_py.dbBox_isVia(self)

    def getTechVia(self):
        return _odb_py.dbBox_getTechVia(self)

    def getBlockVia(self):
        return _odb_py.dbBox_getBlockVia(self)

    def getViaXY(self, *args):
        return _odb_py.dbBox_getViaXY(self, *args)

    def getViaBoxes(self, shapes):
        return _odb_py.dbBox_getViaBoxes(self, shapes)

    def getViaLayerBoxes(self, layer, shapes):
        return _odb_py.dbBox_getViaLayerBoxes(self, layer, shapes)

    def getDir(self):
        return _odb_py.dbBox_getDir(self)

    def getDX(self):
        return _odb_py.dbBox_getDX(self)

    def getDesignRuleWidth(self):
        return _odb_py.dbBox_getDesignRuleWidth(self)

    def setDesignRuleWidth(self, arg2):
        return _odb_py.dbBox_setDesignRuleWidth(self, arg2)

    def getDY(self):
        return _odb_py.dbBox_getDY(self)

    def getWidth(self, dir=1):
        return _odb_py.dbBox_getWidth(self, dir)

    def getLength(self, dir=1):
        return _odb_py.dbBox_getLength(self, dir)

    def setVisited(self, value):
        return _odb_py.dbBox_setVisited(self, value)

    def isVisited(self):
        return _odb_py.dbBox_isVisited(self)

    def getBoxOwner(self):
        return _odb_py.dbBox_getBoxOwner(self)

    def getOwnerType(self):
        return _odb_py.dbBox_getOwnerType(self)

    def getTechLayer(self):
        return _odb_py.dbBox_getTechLayer(self)

    def getLayerMask(self):
        return _odb_py.dbBox_getLayerMask(self)

    def setLayerMask(self, mask):
        return _odb_py.dbBox_setLayerMask(self, mask)

    @staticmethod
    def create(*args):
        return _odb_py.dbBox_create(*args)

    @staticmethod
    def getBox(*args):
        return _odb_py.dbBox_getBox(*args)

    def __init__(self):
        _odb_py.dbBox_swiginit(self, _odb_py.new_dbBox())
    __swig_destroy__ = _odb_py.delete_dbBox

# Register dbBox in _odb_py:
_odb_py.dbBox_swigregister(dbBox)

def dbBox_create(*args):
    return _odb_py.dbBox_create(*args)

def dbBox_getBox(*args):
    return _odb_py.dbBox_getBox(*args)

class dbSBox(dbBox):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UNDEFINED = _odb_py.dbSBox_UNDEFINED
    HORIZONTAL = _odb_py.dbSBox_HORIZONTAL
    VERTICAL = _odb_py.dbSBox_VERTICAL
    OCTILINEAR = _odb_py.dbSBox_OCTILINEAR

    def getWireShapeType(self):
        return _odb_py.dbSBox_getWireShapeType(self)

    def getDirection(self):
        return _odb_py.dbSBox_getDirection(self)

    def getSWire(self):
        return _odb_py.dbSBox_getSWire(self)

    def getOct(self):
        return _odb_py.dbSBox_getOct(self)

    def getViaBottomLayerMask(self):
        return _odb_py.dbSBox_getViaBottomLayerMask(self)

    def getViaCutLayerMask(self):
        return _odb_py.dbSBox_getViaCutLayerMask(self)

    def getViaTopLayerMask(self):
        return _odb_py.dbSBox_getViaTopLayerMask(self)

    def setViaLayerMask(self, bottom, cut, top):
        return _odb_py.dbSBox_setViaLayerMask(self, bottom, cut, top)

    def hasViaLayerMasks(self):
        return _odb_py.dbSBox_hasViaLayerMasks(self)

    def smashVia(self):
        return _odb_py.dbSBox_smashVia(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbSBox_create(*args)

    @staticmethod
    def getSBox(block, oid):
        return _odb_py.dbSBox_getSBox(block, oid)

    @staticmethod
    def destroy(box):
        return _odb_py.dbSBox_destroy(box)

    def __init__(self):
        _odb_py.dbSBox_swiginit(self, _odb_py.new_dbSBox())
    __swig_destroy__ = _odb_py.delete_dbSBox

# Register dbSBox in _odb_py:
_odb_py.dbSBox_swigregister(dbSBox)

def dbSBox_create(*args):
    return _odb_py.dbSBox_create(*args)

def dbSBox_getSBox(block, oid):
    return _odb_py.dbSBox_getSBox(block, oid)

def dbSBox_destroy(box):
    return _odb_py.dbSBox_destroy(box)

class dbChip(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBlock(self):
        return _odb_py.dbChip_getBlock(self)

    @staticmethod
    def create(db):
        return _odb_py.dbChip_create(db)

    @staticmethod
    def getChip(db, oid):
        return _odb_py.dbChip_getChip(db, oid)

    @staticmethod
    def destroy(chip):
        return _odb_py.dbChip_destroy(chip)

    def __init__(self):
        _odb_py.dbChip_swiginit(self, _odb_py.new_dbChip())
    __swig_destroy__ = _odb_py.delete_dbChip

# Register dbChip in _odb_py:
_odb_py.dbChip_swigregister(dbChip)

def dbChip_create(db):
    return _odb_py.dbChip_create(db)

def dbChip_getChip(db, oid):
    return _odb_py.dbChip_getChip(db, oid)

def dbChip_destroy(chip):
    return _odb_py.dbChip_destroy(chip)

class dbBlock(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbBlock_getName(self)

    def getConstName(self):
        return _odb_py.dbBlock_getConstName(self)

    def getBBox(self):
        return _odb_py.dbBlock_getBBox(self)

    def getChip(self):
        return _odb_py.dbBlock_getChip(self)

    def getDataBase(self):
        return _odb_py.dbBlock_getDataBase(self)

    def getTech(self):
        return _odb_py.dbBlock_getTech(self)

    def getParent(self):
        return _odb_py.dbBlock_getParent(self)

    def getParentInst(self):
        return _odb_py.dbBlock_getParentInst(self)

    def getTopModule(self):
        return _odb_py.dbBlock_getTopModule(self)

    def getChildren(self):
        return _odb_py.dbBlock_getChildren(self)

    def findChild(self, name):
        return _odb_py.dbBlock_findChild(self, name)

    def getBTerms(self):
        return _odb_py.dbBlock_getBTerms(self)

    def findBTerm(self, name):
        return _odb_py.dbBlock_findBTerm(self, name)

    def getITerms(self):
        return _odb_py.dbBlock_getITerms(self)

    def getInsts(self):
        return _odb_py.dbBlock_getInsts(self)

    def getModules(self):
        return _odb_py.dbBlock_getModules(self)

    def getModInsts(self):
        return _odb_py.dbBlock_getModInsts(self)

    def getModNets(self):
        return _odb_py.dbBlock_getModNets(self)

    def getModBTerms(self):
        return _odb_py.dbBlock_getModBTerms(self)

    def getPowerDomains(self):
        return _odb_py.dbBlock_getPowerDomains(self)

    def getLogicPorts(self):
        return _odb_py.dbBlock_getLogicPorts(self)

    def getPowerSwitches(self):
        return _odb_py.dbBlock_getPowerSwitches(self)

    def getIsolations(self):
        return _odb_py.dbBlock_getIsolations(self)

    def getLevelShifters(self):
        return _odb_py.dbBlock_getLevelShifters(self)

    def getGroups(self):
        return _odb_py.dbBlock_getGroups(self)

    def getAccessPoints(self):
        return _odb_py.dbBlock_getAccessPoints(self)

    def getGlobalConnects(self):
        return _odb_py.dbBlock_getGlobalConnects(self)

    def globalConnect(self, *args):
        return _odb_py.dbBlock_globalConnect(self, *args)

    def addGlobalConnect(self, region, instPattern, pinPattern, net, do_connect):
        return _odb_py.dbBlock_addGlobalConnect(self, region, instPattern, pinPattern, net, do_connect)

    def reportGlobalConnect(self):
        return _odb_py.dbBlock_reportGlobalConnect(self)

    def clearGlobalConnect(self):
        return _odb_py.dbBlock_clearGlobalConnect(self)

    def getComponentMaskShift(self):
        return _odb_py.dbBlock_getComponentMaskShift(self)

    def setComponentMaskShift(self, layers):
        return _odb_py.dbBlock_setComponentMaskShift(self, layers)

    def findInst(self, name):
        return _odb_py.dbBlock_findInst(self, name)

    def findModule(self, name):
        return _odb_py.dbBlock_findModule(self, name)

    def findModInst(self, path):
        return _odb_py.dbBlock_findModInst(self, path)

    def findPowerDomain(self, name):
        return _odb_py.dbBlock_findPowerDomain(self, name)

    def findLogicPort(self, name):
        return _odb_py.dbBlock_findLogicPort(self, name)

    def findPowerSwitch(self, name):
        return _odb_py.dbBlock_findPowerSwitch(self, name)

    def findIsolation(self, name):
        return _odb_py.dbBlock_findIsolation(self, name)

    def findLevelShifter(self, name):
        return _odb_py.dbBlock_findLevelShifter(self, name)

    def findGroup(self, name):
        return _odb_py.dbBlock_findGroup(self, name)

    def findSomeInst(self, names, insts):
        return _odb_py.dbBlock_findSomeInst(self, names, insts)

    def findSomeMaster(self, names, masters):
        return _odb_py.dbBlock_findSomeMaster(self, names, masters)

    def findITerm(self, name):
        return _odb_py.dbBlock_findITerm(self, name)

    def getObstructions(self):
        return _odb_py.dbBlock_getObstructions(self)

    def getBlockages(self):
        return _odb_py.dbBlock_getBlockages(self)

    def getNets(self):
        return _odb_py.dbBlock_getNets(self)

    def getCapNodes(self):
        return _odb_py.dbBlock_getCapNodes(self)

    def getRSegs(self):
        return _odb_py.dbBlock_getRSegs(self)

    def findNet(self, name):
        return _odb_py.dbBlock_findNet(self, name)

    def findSomeNet(self, names, nets):
        return _odb_py.dbBlock_findSomeNet(self, names, nets)

    def writeDb(self, filename, allNode=0):
        return _odb_py.dbBlock_writeDb(self, filename, allNode)

    def writeGuides(self, filename):
        return _odb_py.dbBlock_writeGuides(self, filename)

    def findVia(self, name):
        return _odb_py.dbBlock_findVia(self, name)

    def getVias(self):
        return _odb_py.dbBlock_getVias(self)

    def getGCellGrid(self):
        return _odb_py.dbBlock_getGCellGrid(self)

    def getDefUnits(self):
        return _odb_py.dbBlock_getDefUnits(self)

    def setDefUnits(self, units):
        return _odb_py.dbBlock_setDefUnits(self, units)

    def getDbUnitsPerMicron(self):
        return _odb_py.dbBlock_getDbUnitsPerMicron(self)

    def dbuToMicrons(self, *args):
        return _odb_py.dbBlock_dbuToMicrons(self, *args)

    def dbuAreaToMicrons(self, dbu_area):
        return _odb_py.dbBlock_dbuAreaToMicrons(self, dbu_area)

    def micronsToDbu(self, microns):
        return _odb_py.dbBlock_micronsToDbu(self, microns)

    def micronsAreaToDbu(self, micronsArea):
        return _odb_py.dbBlock_micronsAreaToDbu(self, micronsArea)

    def getHierarchyDelimeter(self):
        return _odb_py.dbBlock_getHierarchyDelimeter(self)

    def setBusDelimeters(self, left, right):
        return _odb_py.dbBlock_setBusDelimeters(self, left, right)

    def getBusDelimeters(self, left, right):
        return _odb_py.dbBlock_getBusDelimeters(self, left, right)

    def getExtCount(self, numOfNet, numOfRSeg, numOfCapNode, numOfCCSeg):
        return _odb_py.dbBlock_getExtCount(self, numOfNet, numOfRSeg, numOfCapNode, numOfCCSeg)

    def copyExtDb(self, fr, to, extDbCnt, resFactor, ccFactor, gndcFactor):
        return _odb_py.dbBlock_copyExtDb(self, fr, to, extDbCnt, resFactor, ccFactor, gndcFactor)

    def adjustRC(self, resFactor, ccFactor, gndcFactor):
        return _odb_py.dbBlock_adjustRC(self, resFactor, ccFactor, gndcFactor)

    def groundCC(self, gndFactor):
        return _odb_py.dbBlock_groundCC(self, gndFactor)

    def adjustCC(self, adjFactor, ccThreshHold, nets, halonets):
        return _odb_py.dbBlock_adjustCC(self, adjFactor, ccThreshHold, nets, halonets)

    def undoAdjustedCC(self, nets, halonets):
        return _odb_py.dbBlock_undoAdjustedCC(self, nets, halonets)

    def getCornerCount(self):
        return _odb_py.dbBlock_getCornerCount(self)

    def extCornersAreIndependent(self):
        return _odb_py.dbBlock_extCornersAreIndependent(self)

    def getCornersPerBlock(self):
        return _odb_py.dbBlock_getCornersPerBlock(self)

    def getExtDbCount(self):
        return _odb_py.dbBlock_getExtDbCount(self)

    def getExtCornerName(self, corner, cName):
        return _odb_py.dbBlock_getExtCornerName(self, corner, cName)

    def getExtCornerIndex(self, cornerName):
        return _odb_py.dbBlock_getExtCornerIndex(self, cornerName)

    def setCornerNameList(self, name_list):
        return _odb_py.dbBlock_setCornerNameList(self, name_list)

    def getCornerNameList(self):
        return _odb_py.dbBlock_getCornerNameList(self)

    def setCornerCount(self, *args):
        return _odb_py.dbBlock_setCornerCount(self, *args)

    def setCornersPerBlock(self, cornersPerBlock):
        return _odb_py.dbBlock_setCornersPerBlock(self, cornersPerBlock)

    def initParasiticsValueTables(self):
        return _odb_py.dbBlock_initParasiticsValueTables(self)

    def createExtCornerBlock(self, corner):
        return _odb_py.dbBlock_createExtCornerBlock(self, corner)

    def findExtCornerBlock(self, corner):
        return _odb_py.dbBlock_findExtCornerBlock(self, corner)

    def getExtCornerBlock(self, corner):
        return _odb_py.dbBlock_getExtCornerBlock(self, corner)

    def getTrackGrids(self):
        return _odb_py.dbBlock_getTrackGrids(self)

    def findTrackGrid(self, layer):
        return _odb_py.dbBlock_findTrackGrid(self, layer)

    def getRows(self):
        return _odb_py.dbBlock_getRows(self)

    def getFills(self):
        return _odb_py.dbBlock_getFills(self)

    def getMasters(self, masters):
        return _odb_py.dbBlock_getMasters(self, masters)

    def setDieArea(self, new_rect):
        return _odb_py.dbBlock_setDieArea(self, new_rect)

    def getDieArea(self):
        return _odb_py.dbBlock_getDieArea(self)

    def getCoreArea(self):
        return _odb_py.dbBlock_getCoreArea(self)

    def setExtmi(self, ext):
        return _odb_py.dbBlock_setExtmi(self, ext)

    def getExtmi(self):
        return _odb_py.dbBlock_getExtmi(self)

    def getExtControl(self):
        return _odb_py.dbBlock_getExtControl(self)

    def getDft(self):
        return _odb_py.dbBlock_getDft(self)

    def getExtCornerNames(self, ecl):
        return _odb_py.dbBlock_getExtCornerNames(self, ecl)

    def getCCSegs(self):
        return _odb_py.dbBlock_getCCSegs(self)

    def getSearchDb(self):
        return _odb_py.dbBlock_getSearchDb(self)

    def destroyCCs(self, nets):
        return _odb_py.dbBlock_destroyCCs(self, nets)

    def destroyRSegs(self, nets):
        return _odb_py.dbBlock_destroyRSegs(self, nets)

    def destroyCNs(self, nets, cleanExtid):
        return _odb_py.dbBlock_destroyCNs(self, nets, cleanExtid)

    def destroyParasitics(self, nets):
        return _odb_py.dbBlock_destroyParasitics(self, nets)

    def destroyCornerParasitics(self, nets):
        return _odb_py.dbBlock_destroyCornerParasitics(self, nets)

    def getCcHaloNets(self, changedNets, ccHaloNets):
        return _odb_py.dbBlock_getCcHaloNets(self, changedNets, ccHaloNets)

    def destroyOldParasitics(self, nets, capnn, rsegn):
        return _odb_py.dbBlock_destroyOldParasitics(self, nets, capnn, rsegn)

    def destroyOldCornerParasitics(self, nets, capnn, rsegn):
        return _odb_py.dbBlock_destroyOldCornerParasitics(self, nets, capnn, rsegn)

    def restoreOldCornerParasitics(self, pBlock, nets, coupled_rc, ccHaloNets, capnn, rsegn):
        return _odb_py.dbBlock_restoreOldCornerParasitics(self, pBlock, nets, coupled_rc, ccHaloNets, capnn, rsegn)

    def replaceOldParasitics(self, nets, capnn, rsegn):
        return _odb_py.dbBlock_replaceOldParasitics(self, nets, capnn, rsegn)

    def restoreOldParasitics(self, *args):
        return _odb_py.dbBlock_restoreOldParasitics(self, *args)

    def keepOldParasitics(self, nets, coupled_rc, ccHaloNets, capnn, rsegn):
        return _odb_py.dbBlock_keepOldParasitics(self, nets, coupled_rc, ccHaloNets, capnn, rsegn)

    def keepOldCornerParasitics(self, pBlock, nets, coupled_rc, ccHaloNets, capnn, rsegn):
        return _odb_py.dbBlock_keepOldCornerParasitics(self, pBlock, nets, coupled_rc, ccHaloNets, capnn, rsegn)

    def preExttreeMergeRC(self, max_cap, corner):
        return _odb_py.dbBlock_preExttreeMergeRC(self, max_cap, corner)

    def clear(self):
        return _odb_py.dbBlock_clear(self)

    def getWireUpdatedNets(self, nets):
        return _odb_py.dbBlock_getWireUpdatedNets(self, nets)

    def getRegions(self):
        return _odb_py.dbBlock_getRegions(self)

    def findRegion(self, name):
        return _odb_py.dbBlock_findRegion(self, name)

    def findNonDefaultRule(self, name):
        return _odb_py.dbBlock_findNonDefaultRule(self, name)

    def getNonDefaultRules(self):
        return _odb_py.dbBlock_getNonDefaultRules(self)

    def levelize(self, startingInsts, instsToBeLeveled):
        return _odb_py.dbBlock_levelize(self, startingInsts, instsToBeLeveled)

    def levelizeFromPrimaryInputs(self):
        return _odb_py.dbBlock_levelizeFromPrimaryInputs(self)

    def levelizeFromSequential(self):
        return _odb_py.dbBlock_levelizeFromSequential(self)

    def markBackwardsUser2(self, *args):
        return _odb_py.dbBlock_markBackwardsUser2(self, *args)

    def setDrivingItermsforNets(self):
        return _odb_py.dbBlock_setDrivingItermsforNets(self)

    def clearUserInstFlags(self):
        return _odb_py.dbBlock_clearUserInstFlags(self)

    @staticmethod
    def copyViaTable(dst, src):
        return _odb_py.dbBlock_copyViaTable(dst, src)

    @staticmethod
    def create(*args):
        return _odb_py.dbBlock_create(*args)

    @staticmethod
    def duplicate(block, name=None):
        return _odb_py.dbBlock_duplicate(block, name)

    @staticmethod
    def getBlock(*args):
        return _odb_py.dbBlock_getBlock(*args)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbBlock_destroy(*args)

    @staticmethod
    def differences(block1, block2, out, indent_per_level=4):
        return _odb_py.dbBlock_differences(block1, block2, out, indent_per_level)

    def __init__(self):
        _odb_py.dbBlock_swiginit(self, _odb_py.new_dbBlock())
    __swig_destroy__ = _odb_py.delete_dbBlock

# Register dbBlock in _odb_py:
_odb_py.dbBlock_swigregister(dbBlock)

def dbBlock_copyViaTable(dst, src):
    return _odb_py.dbBlock_copyViaTable(dst, src)

def dbBlock_create(*args):
    return _odb_py.dbBlock_create(*args)

def dbBlock_duplicate(block, name=None):
    return _odb_py.dbBlock_duplicate(block, name)

def dbBlock_getBlock(*args):
    return _odb_py.dbBlock_getBlock(*args)

def dbBlock_destroy(*args):
    return _odb_py.dbBlock_destroy(*args)

def dbBlock_differences(block1, block2, out, indent_per_level=4):
    return _odb_py.dbBlock_differences(block1, block2, out, indent_per_level)

class dbBTerm(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbBTerm_getName(self)

    def getConstName(self):
        return _odb_py.dbBTerm_getConstName(self)

    def rename(self, name):
        return _odb_py.dbBTerm_rename(self, name)

    def getBBox(self):
        return _odb_py.dbBTerm_getBBox(self)

    def setSigType(self, type):
        return _odb_py.dbBTerm_setSigType(self, type)

    def getSigType(self):
        return _odb_py.dbBTerm_getSigType(self)

    def setIoType(self, type):
        return _odb_py.dbBTerm_setIoType(self, type)

    def getIoType(self):
        return _odb_py.dbBTerm_getIoType(self)

    def setSpefMark(self, v):
        return _odb_py.dbBTerm_setSpefMark(self, v)

    def isSetSpefMark(self):
        return _odb_py.dbBTerm_isSetSpefMark(self)

    def setMark(self, v):
        return _odb_py.dbBTerm_setMark(self, v)

    def isSetMark(self):
        return _odb_py.dbBTerm_isSetMark(self)

    def setExtId(self, v):
        return _odb_py.dbBTerm_setExtId(self, v)

    def getExtId(self):
        return _odb_py.dbBTerm_getExtId(self)

    def isSpecial(self):
        return _odb_py.dbBTerm_isSpecial(self)

    def setSpecial(self):
        return _odb_py.dbBTerm_setSpecial(self)

    def getNet(self):
        return _odb_py.dbBTerm_getNet(self)

    def getModNet(self):
        return _odb_py.dbBTerm_getModNet(self)

    def disconnect(self):
        return _odb_py.dbBTerm_disconnect(self)

    def connect(self, *args):
        return _odb_py.dbBTerm_connect(self, *args)

    def getBlock(self):
        return _odb_py.dbBTerm_getBlock(self)

    def getITerm(self):
        return _odb_py.dbBTerm_getITerm(self)

    def getBPins(self):
        return _odb_py.dbBTerm_getBPins(self)

    def getFirstPin(self, shape):
        return _odb_py.dbBTerm_getFirstPin(self, shape)

    def getFirstPinLocation(self):
        return _odb_py.dbBTerm_getFirstPinLocation(self)

    def getFirstPinPlacementStatus(self):
        return _odb_py.dbBTerm_getFirstPinPlacementStatus(self)

    def getGroundPin(self):
        return _odb_py.dbBTerm_getGroundPin(self)

    def setGroundPin(self, pin):
        return _odb_py.dbBTerm_setGroundPin(self, pin)

    def getSupplyPin(self):
        return _odb_py.dbBTerm_getSupplyPin(self)

    def setSupplyPin(self, pin):
        return _odb_py.dbBTerm_setSupplyPin(self, pin)

    @staticmethod
    def create(net, name):
        return _odb_py.dbBTerm_create(net, name)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbBTerm_destroy(*args)

    @staticmethod
    def getBTerm(block, oid):
        return _odb_py.dbBTerm_getBTerm(block, oid)

    def staVertexId(self):
        return _odb_py.dbBTerm_staVertexId(self)

    def staSetVertexId(self, id):
        return _odb_py.dbBTerm_staSetVertexId(self, id)

    def __init__(self):
        _odb_py.dbBTerm_swiginit(self, _odb_py.new_dbBTerm())
    __swig_destroy__ = _odb_py.delete_dbBTerm

# Register dbBTerm in _odb_py:
_odb_py.dbBTerm_swigregister(dbBTerm)

def dbBTerm_create(net, name):
    return _odb_py.dbBTerm_create(net, name)

def dbBTerm_destroy(*args):
    return _odb_py.dbBTerm_destroy(*args)

def dbBTerm_getBTerm(block, oid):
    return _odb_py.dbBTerm_getBTerm(block, oid)

class dbBPin(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getPlacementStatus(self):
        return _odb_py.dbBPin_getPlacementStatus(self)

    def setPlacementStatus(self, status):
        return _odb_py.dbBPin_setPlacementStatus(self, status)

    def getBTerm(self):
        return _odb_py.dbBPin_getBTerm(self)

    def getBoxes(self):
        return _odb_py.dbBPin_getBoxes(self)

    def getBBox(self):
        return _odb_py.dbBPin_getBBox(self)

    def hasEffectiveWidth(self):
        return _odb_py.dbBPin_hasEffectiveWidth(self)

    def setEffectiveWidth(self, w):
        return _odb_py.dbBPin_setEffectiveWidth(self, w)

    def getEffectiveWidth(self):
        return _odb_py.dbBPin_getEffectiveWidth(self)

    def hasMinSpacing(self):
        return _odb_py.dbBPin_hasMinSpacing(self)

    def setMinSpacing(self, w):
        return _odb_py.dbBPin_setMinSpacing(self, w)

    def getMinSpacing(self):
        return _odb_py.dbBPin_getMinSpacing(self)

    def getAccessPoints(self):
        return _odb_py.dbBPin_getAccessPoints(self)

    @staticmethod
    def create(bterm):
        return _odb_py.dbBPin_create(bterm)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbBPin_destroy(*args)

    @staticmethod
    def getBPin(block, oid):
        return _odb_py.dbBPin_getBPin(block, oid)

    def __init__(self):
        _odb_py.dbBPin_swiginit(self, _odb_py.new_dbBPin())
    __swig_destroy__ = _odb_py.delete_dbBPin

# Register dbBPin in _odb_py:
_odb_py.dbBPin_swigregister(dbBPin)

def dbBPin_create(bterm):
    return _odb_py.dbBPin_create(bterm)

def dbBPin_destroy(*args):
    return _odb_py.dbBPin_destroy(*args)

def dbBPin_getBPin(block, oid):
    return _odb_py.dbBPin_getBPin(block, oid)

class dbNet(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbNet_getName(self)

    def getConstName(self):
        return _odb_py.dbNet_getConstName(self)

    def printNetName(self, fp, idFlag=True, newLine=True):
        return _odb_py.dbNet_printNetName(self, fp, idFlag, newLine)

    def rename(self, name):
        return _odb_py.dbNet_rename(self, name)

    def isRCDisconnected(self):
        return _odb_py.dbNet_isRCDisconnected(self)

    def setRCDisconnected(self, value):
        return _odb_py.dbNet_setRCDisconnected(self, value)

    def getWeight(self):
        return _odb_py.dbNet_getWeight(self)

    def setWeight(self, weight):
        return _odb_py.dbNet_setWeight(self, weight)

    def getSourceType(self):
        return _odb_py.dbNet_getSourceType(self)

    def setSourceType(self, type):
        return _odb_py.dbNet_setSourceType(self, type)

    def getXTalkClass(self):
        return _odb_py.dbNet_getXTalkClass(self)

    def setXTalkClass(self, value):
        return _odb_py.dbNet_setXTalkClass(self, value)

    def setDrivingITerm(self, id):
        return _odb_py.dbNet_setDrivingITerm(self, id)

    def getDrivingITerm(self):
        return _odb_py.dbNet_getDrivingITerm(self)

    def hasFixedBump(self):
        return _odb_py.dbNet_hasFixedBump(self)

    def setFixedBump(self, value):
        return _odb_py.dbNet_setFixedBump(self, value)

    def getWireType(self):
        return _odb_py.dbNet_getWireType(self)

    def setWireType(self, wire_type):
        return _odb_py.dbNet_setWireType(self, wire_type)

    def getSigType(self):
        return _odb_py.dbNet_getSigType(self)

    def setSigType(self, sig_type):
        return _odb_py.dbNet_setSigType(self, sig_type)

    def isEnclosed(self, bbox):
        return _odb_py.dbNet_isEnclosed(self, bbox)

    def isMarked(self):
        return _odb_py.dbNet_isMarked(self)

    def isMark_1ed(self):
        return _odb_py.dbNet_isMark_1ed(self)

    def setMark(self, value):
        return _odb_py.dbNet_setMark(self, value)

    def setMark_1(self, value):
        return _odb_py.dbNet_setMark_1(self, value)

    def isSelect(self):
        return _odb_py.dbNet_isSelect(self)

    def setSelect(self, value):
        return _odb_py.dbNet_setSelect(self, value)

    def wireEqual(self, target):
        return _odb_py.dbNet_wireEqual(self, target)

    def wireMatch(self, target):
        return _odb_py.dbNet_wireMatch(self, target)

    def printWire(self, *args):
        return _odb_py.dbNet_printWire(self, *args)

    def isWireOrdered(self):
        return _odb_py.dbNet_isWireOrdered(self)

    def setWireOrdered(self, value):
        return _odb_py.dbNet_setWireOrdered(self, value)

    def isBuffered(self):
        return _odb_py.dbNet_isBuffered(self)

    def setBuffered(self, value):
        return _odb_py.dbNet_setBuffered(self, value)

    def isDisconnected(self):
        return _odb_py.dbNet_isDisconnected(self)

    def setDisconnected(self, value):
        return _odb_py.dbNet_setDisconnected(self, value)

    def setWireAltered(self, value):
        return _odb_py.dbNet_setWireAltered(self, value)

    def isWireAltered(self):
        return _odb_py.dbNet_isWireAltered(self)

    def setRCgraph(self, value):
        return _odb_py.dbNet_setRCgraph(self, value)

    def isRCgraph(self):
        return _odb_py.dbNet_isRCgraph(self)

    def setReduced(self, value):
        return _odb_py.dbNet_setReduced(self, value)

    def isReduced(self):
        return _odb_py.dbNet_isReduced(self)

    def setExtracted(self, value):
        return _odb_py.dbNet_setExtracted(self, value)

    def isExtracted(self):
        return _odb_py.dbNet_isExtracted(self)

    def setSpef(self, value):
        return _odb_py.dbNet_setSpef(self, value)

    def isSpef(self):
        return _odb_py.dbNet_isSpef(self)

    def setDoNotTouch(self, v):
        return _odb_py.dbNet_setDoNotTouch(self, v)

    def isDoNotTouch(self):
        return _odb_py.dbNet_isDoNotTouch(self)

    def getBlock(self):
        return _odb_py.dbNet_getBlock(self)

    def getITerms(self):
        return _odb_py.dbNet_getITerms(self)

    def get1stITerm(self):
        return _odb_py.dbNet_get1stITerm(self)

    def get1stSignalInput(self, io):
        return _odb_py.dbNet_get1stSignalInput(self, io)

    def getFirstOutput(self):
        return _odb_py.dbNet_getFirstOutput(self)

    def getBTerms(self):
        return _odb_py.dbNet_getBTerms(self)

    def get1stBTerm(self):
        return _odb_py.dbNet_get1stBTerm(self)

    def getSWires(self):
        return _odb_py.dbNet_getSWires(self)

    def getWire(self):
        return _odb_py.dbNet_getWire(self)

    def getFirstSWire(self):
        return _odb_py.dbNet_getFirstSWire(self)

    def donateWire(self, tnet, new_rsegs):
        return _odb_py.dbNet_donateWire(self, tnet, new_rsegs)

    def getGlobalWire(self):
        return _odb_py.dbNet_getGlobalWire(self)

    def isSpecial(self):
        return _odb_py.dbNet_isSpecial(self)

    def setSpecial(self):
        return _odb_py.dbNet_setSpecial(self)

    def clearSpecial(self):
        return _odb_py.dbNet_clearSpecial(self)

    def isConnectedByAbutment(self):
        return _odb_py.dbNet_isConnectedByAbutment(self)

    def setIOflag(self):
        return _odb_py.dbNet_setIOflag(self)

    def isIO(self):
        return _odb_py.dbNet_isIO(self)

    def isWildConnected(self):
        return _odb_py.dbNet_isWildConnected(self)

    def setWildConnected(self):
        return _odb_py.dbNet_setWildConnected(self)

    def clearWildConnected(self):
        return _odb_py.dbNet_clearWildConnected(self)

    def getGndcCalibFactor(self):
        return _odb_py.dbNet_getGndcCalibFactor(self)

    def setGndcCalibFactor(self, gndcCalib):
        return _odb_py.dbNet_setGndcCalibFactor(self, gndcCalib)

    def calibrateCapacitance(self):
        return _odb_py.dbNet_calibrateCapacitance(self)

    def calibrateGndCap(self):
        return _odb_py.dbNet_calibrateGndCap(self)

    def calibrateCouplingCap(self, *args):
        return _odb_py.dbNet_calibrateCouplingCap(self, *args)

    def getCcCalibFactor(self):
        return _odb_py.dbNet_getCcCalibFactor(self)

    def setCcCalibFactor(self, ccCalib):
        return _odb_py.dbNet_setCcCalibFactor(self, ccCalib)

    def adjustNetRes(self, *args):
        return _odb_py.dbNet_adjustNetRes(self, *args)

    def adjustNetGndCap(self, *args):
        return _odb_py.dbNet_adjustNetGndCap(self, *args)

    def getCcAdjustFactor(self):
        return _odb_py.dbNet_getCcAdjustFactor(self)

    def setCcAdjustFactor(self, factor):
        return _odb_py.dbNet_setCcAdjustFactor(self, factor)

    def getCcAdjustOrder(self):
        return _odb_py.dbNet_getCcAdjustOrder(self)

    def setCcAdjustOrder(self, order):
        return _odb_py.dbNet_setCcAdjustOrder(self, order)

    def adjustCC(self, adjOrder, adjFactor, ccThreshHold, adjustedCC, halonets):
        return _odb_py.dbNet_adjustCC(self, adjOrder, adjFactor, ccThreshHold, adjustedCC, halonets)

    def undoAdjustedCC(self, adjustedCC, halonets):
        return _odb_py.dbNet_undoAdjustedCC(self, adjustedCC, halonets)

    def groundCC(self, gndFactor):
        return _odb_py.dbNet_groundCC(self, gndFactor)

    def addDbCc(self, cap):
        return _odb_py.dbNet_addDbCc(self, cap)

    def getDbCc(self):
        return _odb_py.dbNet_getDbCc(self)

    def setDbCc(self, cap):
        return _odb_py.dbNet_setDbCc(self, cap)

    def getRefCc(self):
        return _odb_py.dbNet_getRefCc(self)

    def setRefCc(self, cap):
        return _odb_py.dbNet_setRefCc(self, cap)

    def getCcMatchRatio(self):
        return _odb_py.dbNet_getCcMatchRatio(self)

    def setCcMatchRatio(self, ratio):
        return _odb_py.dbNet_setCcMatchRatio(self, ratio)

    def getGndTotalCap(self, gndcap, totalcap, MillerMult):
        return _odb_py.dbNet_getGndTotalCap(self, gndcap, totalcap, MillerMult)

    def preExttreeMergeRC(self, max_cap, corner):
        return _odb_py.dbNet_preExttreeMergeRC(self, max_cap, corner)

    def findCapNode(self, nodeId):
        return _odb_py.dbNet_findCapNode(self, nodeId)

    def printCapN(self, type):
        return _odb_py.dbNet_printCapN(self, type)

    def donateRC(self, donorterm, rcvterm, rtrseg, lastrrseg, lastrcapnd, ricapndCnt, fstdrseg, dtrseg, fstdcapnd, gndcc, bridgeRseg):
        return _odb_py.dbNet_donateRC(self, donorterm, rcvterm, rtrseg, lastrrseg, lastrcapnd, ricapndCnt, fstdrseg, dtrseg, fstdcapnd, gndcc, bridgeRseg)

    def unDonateRC(self, rtrseg, lastrrseg, it, lastrcapnd, ricapndCnt, dtrseg, fstdrseg, fstdcapnd, ot, gndcc):
        return _odb_py.dbNet_unDonateRC(self, rtrseg, lastrrseg, it, lastrcapnd, ricapndCnt, dtrseg, fstdrseg, fstdcapnd, ot, gndcc)

    def getCapNodes(self):
        return _odb_py.dbNet_getCapNodes(self)

    def destroyCapNodes(self, cleanExtid):
        return _odb_py.dbNet_destroyCapNodes(self, cleanExtid)

    def reverseRSegs(self):
        return _odb_py.dbNet_reverseRSegs(self)

    def createZeroRc(self, foreign):
        return _odb_py.dbNet_createZeroRc(self, foreign)

    def set1stRSegId(self, rseg_id):
        return _odb_py.dbNet_set1stRSegId(self, rseg_id)

    def getZeroRSeg(self):
        return _odb_py.dbNet_getZeroRSeg(self)

    def get1stRSegId(self):
        return _odb_py.dbNet_get1stRSegId(self)

    def findRSeg(self, srcn, tgtn):
        return _odb_py.dbNet_findRSeg(self, srcn, tgtn)

    def set1stCapNodeId(self, capn_id):
        return _odb_py.dbNet_set1stCapNodeId(self, capn_id)

    def get1stCapNodeId(self):
        return _odb_py.dbNet_get1stCapNodeId(self)

    def setTermExtIds(self, capId):
        return _odb_py.dbNet_setTermExtIds(self, capId)

    def anchoredRSeg(self):
        return _odb_py.dbNet_anchoredRSeg(self)

    def printRSeg(self, type):
        return _odb_py.dbNet_printRSeg(self, type)

    def printWnP(self, type):
        return _odb_py.dbNet_printWnP(self, type)

    def getRSegCount(self):
        return _odb_py.dbNet_getRSegCount(self)

    def getRSegs(self):
        return _odb_py.dbNet_getRSegs(self)

    def collapseInternalCapNum(self, capNodeMap):
        return _odb_py.dbNet_collapseInternalCapNum(self, capNodeMap)

    def maxInternalCapNum(self):
        return _odb_py.dbNet_maxInternalCapNum(self)

    def getCapNodeCount(self):
        return _odb_py.dbNet_getCapNodeCount(self)

    def getCcCount(self):
        return _odb_py.dbNet_getCcCount(self)

    def destroyRSegs(self):
        return _odb_py.dbNet_destroyRSegs(self)

    def reverseCCSegs(self):
        return _odb_py.dbNet_reverseCCSegs(self)

    def getSrcCCSegs(self, segs):
        return _odb_py.dbNet_getSrcCCSegs(self, segs)

    def getTgtCCSegs(self, segs):
        return _odb_py.dbNet_getTgtCCSegs(self, segs)

    def getCouplingNets(self, corner, ccThreshold, cnets):
        return _odb_py.dbNet_getCouplingNets(self, corner, ccThreshold, cnets)

    def destroyCCSegs(self):
        return _odb_py.dbNet_destroyCCSegs(self)

    def destroyParasitics(self):
        return _odb_py.dbNet_destroyParasitics(self)

    def getTotalCapacitance(self, corner=0, cc=False):
        return _odb_py.dbNet_getTotalCapacitance(self, corner, cc)

    def getTotalCouplingCap(self, corner=0):
        return _odb_py.dbNet_getTotalCouplingCap(self, corner)

    def getTotalResistance(self, corner=0):
        return _odb_py.dbNet_getTotalResistance(self, corner)

    def setNonDefaultRule(self, rule):
        return _odb_py.dbNet_setNonDefaultRule(self, rule)

    def getNonDefaultRule(self):
        return _odb_py.dbNet_getNonDefaultRule(self)

    def getNetStats(self, wireCnt, viaCnt, len, layerCnt, levelTable):
        return _odb_py.dbNet_getNetStats(self, wireCnt, viaCnt, len, layerCnt, levelTable)

    def getWireCount(self, wireCnt, viaCnt):
        return _odb_py.dbNet_getWireCount(self, wireCnt, viaCnt)

    def getSignalWireCount(self, wireCnt, viaCnt):
        return _odb_py.dbNet_getSignalWireCount(self, wireCnt, viaCnt)

    def getPowerWireCount(self, wireCnt, viaCnt):
        return _odb_py.dbNet_getPowerWireCount(self, wireCnt, viaCnt)

    def getTermCount(self):
        return _odb_py.dbNet_getTermCount(self)

    def getITermCount(self):
        return _odb_py.dbNet_getITermCount(self)

    def getBTermCount(self):
        return _odb_py.dbNet_getBTermCount(self)

    def getTermBBox(self):
        return _odb_py.dbNet_getTermBBox(self)

    def destroySWires(self):
        return _odb_py.dbNet_destroySWires(self)

    @staticmethod
    def create(block, name, skipExistingCheck=False):
        return _odb_py.dbNet_create(block, name, skipExistingCheck)

    @staticmethod
    def markNets(nets, block, mk):
        return _odb_py.dbNet_markNets(nets, block, mk)

    def setLevelAtFanout(self, level, fromPI, instVector):
        return _odb_py.dbNet_setLevelAtFanout(self, level, fromPI, instVector)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbNet_destroy(*args)

    @staticmethod
    def getNet(block, oid):
        return _odb_py.dbNet_getNet(block, oid)

    @staticmethod
    def getValidNet(block, oid):
        return _odb_py.dbNet_getValidNet(block, oid)

    def getGuides(self):
        return _odb_py.dbNet_getGuides(self)

    def clearGuides(self):
        return _odb_py.dbNet_clearGuides(self)

    def getTracks(self):
        return _odb_py.dbNet_getTracks(self)

    def clearTracks(self):
        return _odb_py.dbNet_clearTracks(self)

    def __init__(self):
        _odb_py.dbNet_swiginit(self, _odb_py.new_dbNet())
    __swig_destroy__ = _odb_py.delete_dbNet

# Register dbNet in _odb_py:
_odb_py.dbNet_swigregister(dbNet)

def dbNet_create(block, name, skipExistingCheck=False):
    return _odb_py.dbNet_create(block, name, skipExistingCheck)

def dbNet_markNets(nets, block, mk):
    return _odb_py.dbNet_markNets(nets, block, mk)

def dbNet_destroy(*args):
    return _odb_py.dbNet_destroy(*args)

def dbNet_getNet(block, oid):
    return _odb_py.dbNet_getNet(block, oid)

def dbNet_getValidNet(block, oid):
    return _odb_py.dbNet_getValidNet(block, oid)

class dbInst(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbInst_getName(self)

    def getConstName(self):
        return _odb_py.dbInst_getConstName(self)

    def isNamed(self, name):
        return _odb_py.dbInst_isNamed(self, name)

    def rename(self, name):
        return _odb_py.dbInst_rename(self, name)

    def getOrigin(self):
        return _odb_py.dbInst_getOrigin(self)

    def setOrigin(self, x, y):
        return _odb_py.dbInst_setOrigin(self, x, y)

    def getOrient(self):
        return _odb_py.dbInst_getOrient(self)

    def setOrient(self, orient):
        return _odb_py.dbInst_setOrient(self, orient)

    def getLocation(self, *args):
        return _odb_py.dbInst_getLocation(self, *args)

    def setLocation(self, x, y):
        return _odb_py.dbInst_setLocation(self, x, y)

    def setLocationOrient(self, orient):
        return _odb_py.dbInst_setLocationOrient(self, orient)

    def getTransform(self):
        return _odb_py.dbInst_getTransform(self)

    def setTransform(self, t):
        return _odb_py.dbInst_setTransform(self, t)

    def getHierTransform(self, t):
        return _odb_py.dbInst_getHierTransform(self, t)

    def getBBox(self):
        return _odb_py.dbInst_getBBox(self)

    def getPlacementStatus(self):
        return _odb_py.dbInst_getPlacementStatus(self)

    def isFixed(self):
        return _odb_py.dbInst_isFixed(self)

    def isPlaced(self):
        return _odb_py.dbInst_isPlaced(self)

    def setPlacementStatus(self, status):
        return _odb_py.dbInst_setPlacementStatus(self, status)

    def getEcoCreate(self):
        return _odb_py.dbInst_getEcoCreate(self)

    def getEcoDestroy(self):
        return _odb_py.dbInst_getEcoDestroy(self)

    def getEcoModify(self):
        return _odb_py.dbInst_getEcoModify(self)

    def setEcoCreate(self, v):
        return _odb_py.dbInst_setEcoCreate(self, v)

    def setEcoDestroy(self, v):
        return _odb_py.dbInst_setEcoDestroy(self, v)

    def setEcoModify(self, v):
        return _odb_py.dbInst_setEcoModify(self, v)

    def getUserFlag1(self):
        return _odb_py.dbInst_getUserFlag1(self)

    def setUserFlag1(self):
        return _odb_py.dbInst_setUserFlag1(self)

    def clearUserFlag1(self):
        return _odb_py.dbInst_clearUserFlag1(self)

    def getUserFlag2(self):
        return _odb_py.dbInst_getUserFlag2(self)

    def setUserFlag2(self):
        return _odb_py.dbInst_setUserFlag2(self)

    def clearUserFlag2(self):
        return _odb_py.dbInst_clearUserFlag2(self)

    def getUserFlag3(self):
        return _odb_py.dbInst_getUserFlag3(self)

    def setUserFlag3(self):
        return _odb_py.dbInst_setUserFlag3(self)

    def clearUserFlag3(self):
        return _odb_py.dbInst_clearUserFlag3(self)

    def setDoNotTouch(self, v):
        return _odb_py.dbInst_setDoNotTouch(self, v)

    def isDoNotTouch(self):
        return _odb_py.dbInst_isDoNotTouch(self)

    def getBlock(self):
        return _odb_py.dbInst_getBlock(self)

    def getMaster(self):
        return _odb_py.dbInst_getMaster(self)

    def getGroup(self):
        return _odb_py.dbInst_getGroup(self)

    def getITerms(self):
        return _odb_py.dbInst_getITerms(self)

    def getFirstOutput(self):
        return _odb_py.dbInst_getFirstOutput(self)

    def getRegion(self):
        return _odb_py.dbInst_getRegion(self)

    def getModule(self):
        return _odb_py.dbInst_getModule(self)

    def findITerm(self, terminal_name):
        return _odb_py.dbInst_findITerm(self, terminal_name)

    def getConnectivity(self, *args):
        return _odb_py.dbInst_getConnectivity(self, *args)

    def bindBlock(self, block, force=False):
        return _odb_py.dbInst_bindBlock(self, block, force)

    def unbindBlock(self):
        return _odb_py.dbInst_unbindBlock(self)

    def resetHierarchy(self, verbose):
        return _odb_py.dbInst_resetHierarchy(self, verbose)

    def getChild(self):
        return _odb_py.dbInst_getChild(self)

    def getParent(self):
        return _odb_py.dbInst_getParent(self)

    def getChildren(self):
        return _odb_py.dbInst_getChildren(self)

    def isHierarchical(self):
        return _odb_py.dbInst_isHierarchical(self)

    def getHalo(self):
        return _odb_py.dbInst_getHalo(self)

    def getWeight(self):
        return _odb_py.dbInst_getWeight(self)

    def setWeight(self, weight):
        return _odb_py.dbInst_setWeight(self, weight)

    def getSourceType(self):
        return _odb_py.dbInst_getSourceType(self)

    def setSourceType(self, type):
        return _odb_py.dbInst_setSourceType(self, type)

    def getITerm(self, *args):
        return _odb_py.dbInst_getITerm(self, *args)

    def swapMaster(self, master):
        return _odb_py.dbInst_swapMaster(self, master)

    def getLevel(self):
        return _odb_py.dbInst_getLevel(self)

    def setLevel(self, v, fromPI):
        return _odb_py.dbInst_setLevel(self, v, fromPI)

    def isBlock(self):
        return _odb_py.dbInst_isBlock(self)

    def isCore(self):
        return _odb_py.dbInst_isCore(self)

    def isPad(self):
        return _odb_py.dbInst_isPad(self)

    def isEndCap(self):
        return _odb_py.dbInst_isEndCap(self)

    def setPinAccessIdx(self, idx):
        return _odb_py.dbInst_setPinAccessIdx(self, idx)

    def getPinAccessIdx(self):
        return _odb_py.dbInst_getPinAccessIdx(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbInst_create(*args)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbInst_destroy(*args)

    @staticmethod
    def getInst(block, oid):
        return _odb_py.dbInst_getInst(block, oid)

    @staticmethod
    def getValidInst(block, oid):
        return _odb_py.dbInst_getValidInst(block, oid)

    def __init__(self):
        _odb_py.dbInst_swiginit(self, _odb_py.new_dbInst())
    __swig_destroy__ = _odb_py.delete_dbInst

# Register dbInst in _odb_py:
_odb_py.dbInst_swigregister(dbInst)

def dbInst_create(*args):
    return _odb_py.dbInst_create(*args)

def dbInst_destroy(*args):
    return _odb_py.dbInst_destroy(*args)

def dbInst_getInst(block, oid):
    return _odb_py.dbInst_getInst(block, oid)

def dbInst_getValidInst(block, oid):
    return _odb_py.dbInst_getValidInst(block, oid)

class dbITerm(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getInst(self):
        return _odb_py.dbITerm_getInst(self)

    def getNet(self):
        return _odb_py.dbITerm_getNet(self)

    def getModNet(self):
        return _odb_py.dbITerm_getModNet(self)

    def getMTerm(self):
        return _odb_py.dbITerm_getMTerm(self)

    def getName(self, *args):
        return _odb_py.dbITerm_getName(self, *args)

    def getBBox(self):
        return _odb_py.dbITerm_getBBox(self)

    def getBlock(self):
        return _odb_py.dbITerm_getBlock(self)

    def getSigType(self):
        return _odb_py.dbITerm_getSigType(self)

    def getIoType(self):
        return _odb_py.dbITerm_getIoType(self)

    def isInputSignal(self, io=True):
        return _odb_py.dbITerm_isInputSignal(self, io)

    def isOutputSignal(self, io=True):
        return _odb_py.dbITerm_isOutputSignal(self, io)

    def setSpef(self, v):
        return _odb_py.dbITerm_setSpef(self, v)

    def isSpef(self):
        return _odb_py.dbITerm_isSpef(self)

    def setExtId(self, v):
        return _odb_py.dbITerm_setExtId(self, v)

    def getExtId(self):
        return _odb_py.dbITerm_getExtId(self)

    def isSpecial(self):
        return _odb_py.dbITerm_isSpecial(self)

    def setSpecial(self):
        return _odb_py.dbITerm_setSpecial(self)

    def clearSpecial(self):
        return _odb_py.dbITerm_clearSpecial(self)

    def setClocked(self, v):
        return _odb_py.dbITerm_setClocked(self, v)

    def isClocked(self):
        return _odb_py.dbITerm_isClocked(self)

    def setMark(self, v):
        return _odb_py.dbITerm_setMark(self, v)

    def isSetMark(self):
        return _odb_py.dbITerm_isSetMark(self)

    def isConnected(self):
        return _odb_py.dbITerm_isConnected(self)

    def setConnected(self):
        return _odb_py.dbITerm_setConnected(self)

    def clearConnected(self):
        return _odb_py.dbITerm_clearConnected(self)

    def getBTerm(self):
        return _odb_py.dbITerm_getBTerm(self)

    def connect(self, *args):
        return _odb_py.dbITerm_connect(self, *args)

    def disconnect(self):
        return _odb_py.dbITerm_disconnect(self)

    def getAvgXY(self):
        return _odb_py.dbITerm_getAvgXY(self)

    def getGeometries(self):
        return _odb_py.dbITerm_getGeometries(self)

    def setAccessPoint(self, pin, ap):
        return _odb_py.dbITerm_setAccessPoint(self, pin, ap)

    def getPrefAccessPoints(self):
        return _odb_py.dbITerm_getPrefAccessPoints(self)

    def getAccessPoints(self):
        return _odb_py.dbITerm_getAccessPoints(self)

    @staticmethod
    def getITerm(block, oid):
        return _odb_py.dbITerm_getITerm(block, oid)

    def staVertexId(self):
        return _odb_py.dbITerm_staVertexId(self)

    def staSetVertexId(self, id):
        return _odb_py.dbITerm_staSetVertexId(self, id)

    def __init__(self):
        _odb_py.dbITerm_swiginit(self, _odb_py.new_dbITerm())
    __swig_destroy__ = _odb_py.delete_dbITerm

# Register dbITerm in _odb_py:
_odb_py.dbITerm_swigregister(dbITerm)

def dbITerm_getITerm(block, oid):
    return _odb_py.dbITerm_getITerm(block, oid)

class dbVia(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbVia_getName(self)

    def getConstName(self):
        return _odb_py.dbVia_getConstName(self)

    def getPattern(self):
        return _odb_py.dbVia_getPattern(self)

    def setPattern(self, pattern):
        return _odb_py.dbVia_setPattern(self, pattern)

    def setViaGenerateRule(self, rule):
        return _odb_py.dbVia_setViaGenerateRule(self, rule)

    def getViaGenerateRule(self):
        return _odb_py.dbVia_getViaGenerateRule(self)

    def hasParams(self):
        return _odb_py.dbVia_hasParams(self)

    def setViaParams(self, params):
        return _odb_py.dbVia_setViaParams(self, params)

    def getViaParams(self):
        return _odb_py.dbVia_getViaParams(self)

    def getBlock(self):
        return _odb_py.dbVia_getBlock(self)

    def getBBox(self):
        return _odb_py.dbVia_getBBox(self)

    def getBoxes(self):
        return _odb_py.dbVia_getBoxes(self)

    def getTopLayer(self):
        return _odb_py.dbVia_getTopLayer(self)

    def getBottomLayer(self):
        return _odb_py.dbVia_getBottomLayer(self)

    def isViaRotated(self):
        return _odb_py.dbVia_isViaRotated(self)

    def getOrient(self):
        return _odb_py.dbVia_getOrient(self)

    def getTechVia(self):
        return _odb_py.dbVia_getTechVia(self)

    def getBlockVia(self):
        return _odb_py.dbVia_getBlockVia(self)

    def setDefault(self, arg2):
        return _odb_py.dbVia_setDefault(self, arg2)

    def isDefault(self):
        return _odb_py.dbVia_isDefault(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbVia_create(*args)

    @staticmethod
    def copy(*args):
        return _odb_py.dbVia_copy(*args)

    @staticmethod
    def getVia(block, oid):
        return _odb_py.dbVia_getVia(block, oid)

    def __init__(self):
        _odb_py.dbVia_swiginit(self, _odb_py.new_dbVia())
    __swig_destroy__ = _odb_py.delete_dbVia

# Register dbVia in _odb_py:
_odb_py.dbVia_swigregister(dbVia)

def dbVia_create(*args):
    return _odb_py.dbVia_create(*args)

def dbVia_copy(*args):
    return _odb_py.dbVia_copy(*args)

def dbVia_getVia(block, oid):
    return _odb_py.dbVia_getVia(block, oid)

class dbWire(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBlock(self):
        return _odb_py.dbWire_getBlock(self)

    def getNet(self):
        return _odb_py.dbWire_getNet(self)

    def append(self, wire, singleSegmentWire=False):
        return _odb_py.dbWire_append(self, wire, singleSegmentWire)

    def shuffleWireSeg(self, newNets, new_rsegs):
        return _odb_py.dbWire_shuffleWireSeg(self, newNets, new_rsegs)

    def getTermJid(self, termid):
        return _odb_py.dbWire_getTermJid(self, termid)

    def equal(self, target):
        return _odb_py.dbWire_equal(self, target)

    def getShape(self, shape_id, shape):
        return _odb_py.dbWire_getShape(self, shape_id, shape)

    def getSegment(self, *args):
        return _odb_py.dbWire_getSegment(self, *args)

    def getPrevVia(self, shape_id, shape):
        return _odb_py.dbWire_getPrevVia(self, shape_id, shape)

    def getNextVia(self, shape_id, shape):
        return _odb_py.dbWire_getNextVia(self, shape_id, shape)

    def getViaBoxes(self, via_shape_id, shapes):
        return _odb_py.dbWire_getViaBoxes(self, via_shape_id, shapes)

    def isGlobalWire(self):
        return _odb_py.dbWire_isGlobalWire(self)

    def getBBox(self):
        return _odb_py.dbWire_getBBox(self)

    def getLength(self):
        return _odb_py.dbWire_getLength(self)

    def length(self):
        return _odb_py.dbWire_length(self)

    def count(self):
        return _odb_py.dbWire_count(self)

    def getCoord(self, jid):
        return _odb_py.dbWire_getCoord(self, jid)

    def getProperty(self, jid, property):
        return _odb_py.dbWire_getProperty(self, jid, property)

    def setProperty(self, jid, property):
        return _odb_py.dbWire_setProperty(self, jid, property)

    def getData(self, n):
        return _odb_py.dbWire_getData(self, n)

    def getOpcode(self, n):
        return _odb_py.dbWire_getOpcode(self, n)

    def printWire(self, *args):
        return _odb_py.dbWire_printWire(self, *args)

    def attach(self, net):
        return _odb_py.dbWire_attach(self, net)

    def detach(self):
        return _odb_py.dbWire_detach(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbWire_create(*args)

    @staticmethod
    def getWire(block, oid):
        return _odb_py.dbWire_getWire(block, oid)

    @staticmethod
    def destroy(wire):
        return _odb_py.dbWire_destroy(wire)

    def getRawWireData(self, data, op_codes):
        return _odb_py.dbWire_getRawWireData(self, data, op_codes)

    def setRawWireData(self, data, op_codes):
        return _odb_py.dbWire_setRawWireData(self, data, op_codes)

    def __init__(self):
        _odb_py.dbWire_swiginit(self, _odb_py.new_dbWire())
    __swig_destroy__ = _odb_py.delete_dbWire

# Register dbWire in _odb_py:
_odb_py.dbWire_swigregister(dbWire)

def dbWire_create(*args):
    return _odb_py.dbWire_create(*args)

def dbWire_getWire(block, oid):
    return _odb_py.dbWire_getWire(block, oid)

def dbWire_destroy(wire):
    return _odb_py.dbWire_destroy(wire)

class dbSWire(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBlock(self):
        return _odb_py.dbSWire_getBlock(self)

    def getNet(self):
        return _odb_py.dbSWire_getNet(self)

    def getWireType(self):
        return _odb_py.dbSWire_getWireType(self)

    def getShield(self):
        return _odb_py.dbSWire_getShield(self)

    def getWires(self):
        return _odb_py.dbSWire_getWires(self)

    @staticmethod
    def create(net, type, shield=None):
        return _odb_py.dbSWire_create(net, type, shield)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbSWire_destroy(*args)

    @staticmethod
    def getSWire(block, oid):
        return _odb_py.dbSWire_getSWire(block, oid)

    def __init__(self):
        _odb_py.dbSWire_swiginit(self, _odb_py.new_dbSWire())
    __swig_destroy__ = _odb_py.delete_dbSWire

# Register dbSWire in _odb_py:
_odb_py.dbSWire_swigregister(dbSWire)

def dbSWire_create(net, type, shield=None):
    return _odb_py.dbSWire_create(net, type, shield)

def dbSWire_destroy(*args):
    return _odb_py.dbSWire_destroy(*args)

def dbSWire_getSWire(block, oid):
    return _odb_py.dbSWire_getSWire(block, oid)

class dbTrackGrid(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTechLayer(self):
        return _odb_py.dbTrackGrid_getTechLayer(self)

    def getGridX(self):
        return _odb_py.dbTrackGrid_getGridX(self)

    def getGridY(self):
        return _odb_py.dbTrackGrid_getGridY(self)

    def getBlock(self):
        return _odb_py.dbTrackGrid_getBlock(self)

    def addGridPatternX(self, origin_x, line_count, step):
        return _odb_py.dbTrackGrid_addGridPatternX(self, origin_x, line_count, step)

    def addGridPatternY(self, origin_y, line_count, step):
        return _odb_py.dbTrackGrid_addGridPatternY(self, origin_y, line_count, step)

    def getNumGridPatternsX(self):
        return _odb_py.dbTrackGrid_getNumGridPatternsX(self)

    def getNumGridPatternsY(self):
        return _odb_py.dbTrackGrid_getNumGridPatternsY(self)

    def getGridPatternX(self, i):
        return _odb_py.dbTrackGrid_getGridPatternX(self, i)

    def getGridPatternY(self, i):
        return _odb_py.dbTrackGrid_getGridPatternY(self, i)

    @staticmethod
    def create(block, layer):
        return _odb_py.dbTrackGrid_create(block, layer)

    def getAverageTrackSpacing(self, track_step, track_init, num_tracks):
        return _odb_py.dbTrackGrid_getAverageTrackSpacing(self, track_step, track_init, num_tracks)

    @staticmethod
    def getTrackGrid(block, oid):
        return _odb_py.dbTrackGrid_getTrackGrid(block, oid)

    @staticmethod
    def destroy(grid_):
        return _odb_py.dbTrackGrid_destroy(grid_)

    def __init__(self):
        _odb_py.dbTrackGrid_swiginit(self, _odb_py.new_dbTrackGrid())
    __swig_destroy__ = _odb_py.delete_dbTrackGrid

# Register dbTrackGrid in _odb_py:
_odb_py.dbTrackGrid_swigregister(dbTrackGrid)

def dbTrackGrid_create(block, layer):
    return _odb_py.dbTrackGrid_create(block, layer)

def dbTrackGrid_getTrackGrid(block, oid):
    return _odb_py.dbTrackGrid_getTrackGrid(block, oid)

def dbTrackGrid_destroy(grid_):
    return _odb_py.dbTrackGrid_destroy(grid_)

class dbObstruction(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBBox(self):
        return _odb_py.dbObstruction_getBBox(self)

    def getInstance(self):
        return _odb_py.dbObstruction_getInstance(self)

    def setSlotObstruction(self):
        return _odb_py.dbObstruction_setSlotObstruction(self)

    def isSlotObstruction(self):
        return _odb_py.dbObstruction_isSlotObstruction(self)

    def setFillObstruction(self):
        return _odb_py.dbObstruction_setFillObstruction(self)

    def isFillObstruction(self):
        return _odb_py.dbObstruction_isFillObstruction(self)

    def setExceptPGNetsObstruction(self):
        return _odb_py.dbObstruction_setExceptPGNetsObstruction(self)

    def isExceptPGNetsObstruction(self):
        return _odb_py.dbObstruction_isExceptPGNetsObstruction(self)

    def setPushedDown(self):
        return _odb_py.dbObstruction_setPushedDown(self)

    def isPushedDown(self):
        return _odb_py.dbObstruction_isPushedDown(self)

    def hasEffectiveWidth(self):
        return _odb_py.dbObstruction_hasEffectiveWidth(self)

    def setEffectiveWidth(self, w):
        return _odb_py.dbObstruction_setEffectiveWidth(self, w)

    def getEffectiveWidth(self):
        return _odb_py.dbObstruction_getEffectiveWidth(self)

    def hasMinSpacing(self):
        return _odb_py.dbObstruction_hasMinSpacing(self)

    def setMinSpacing(self, w):
        return _odb_py.dbObstruction_setMinSpacing(self, w)

    def getMinSpacing(self):
        return _odb_py.dbObstruction_getMinSpacing(self)

    def getBlock(self):
        return _odb_py.dbObstruction_getBlock(self)

    @staticmethod
    def destroy(obstruction):
        return _odb_py.dbObstruction_destroy(obstruction)

    @staticmethod
    def create(block, layer, x1, y1, x2, y2, inst=None):
        return _odb_py.dbObstruction_create(block, layer, x1, y1, x2, y2, inst)

    @staticmethod
    def getObstruction(block, oid):
        return _odb_py.dbObstruction_getObstruction(block, oid)

    def __init__(self):
        _odb_py.dbObstruction_swiginit(self, _odb_py.new_dbObstruction())
    __swig_destroy__ = _odb_py.delete_dbObstruction

# Register dbObstruction in _odb_py:
_odb_py.dbObstruction_swigregister(dbObstruction)

def dbObstruction_destroy(obstruction):
    return _odb_py.dbObstruction_destroy(obstruction)

def dbObstruction_create(block, layer, x1, y1, x2, y2, inst=None):
    return _odb_py.dbObstruction_create(block, layer, x1, y1, x2, y2, inst)

def dbObstruction_getObstruction(block, oid):
    return _odb_py.dbObstruction_getObstruction(block, oid)

class dbBlockage(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBBox(self):
        return _odb_py.dbBlockage_getBBox(self)

    def getInstance(self):
        return _odb_py.dbBlockage_getInstance(self)

    def setPushedDown(self):
        return _odb_py.dbBlockage_setPushedDown(self)

    def isPushedDown(self):
        return _odb_py.dbBlockage_isPushedDown(self)

    def setSoft(self):
        return _odb_py.dbBlockage_setSoft(self)

    def isSoft(self):
        return _odb_py.dbBlockage_isSoft(self)

    def setMaxDensity(self, max_density):
        return _odb_py.dbBlockage_setMaxDensity(self, max_density)

    def getMaxDensity(self):
        return _odb_py.dbBlockage_getMaxDensity(self)

    def getBlock(self):
        return _odb_py.dbBlockage_getBlock(self)

    @staticmethod
    def create(block, x1, y1, x2, y2, inst=None):
        return _odb_py.dbBlockage_create(block, x1, y1, x2, y2, inst)

    @staticmethod
    def getBlockage(block, oid):
        return _odb_py.dbBlockage_getBlockage(block, oid)

    def __init__(self):
        _odb_py.dbBlockage_swiginit(self, _odb_py.new_dbBlockage())
    __swig_destroy__ = _odb_py.delete_dbBlockage

# Register dbBlockage in _odb_py:
_odb_py.dbBlockage_swigregister(dbBlockage)

def dbBlockage_create(block, x1, y1, x2, y2, inst=None):
    return _odb_py.dbBlockage_create(block, x1, y1, x2, y2, inst)

def dbBlockage_getBlockage(block, oid):
    return _odb_py.dbBlockage_getBlockage(block, oid)

class dbCapNode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def addCapnCapacitance(self, other):
        return _odb_py.dbCapNode_addCapnCapacitance(self, other)

    def addGndCap(self, gndcap, totalcap):
        return _odb_py.dbCapNode_addGndCap(self, gndcap, totalcap)

    def addGndTotalCap(self, gndcap, totalcap, MillerMult):
        return _odb_py.dbCapNode_addGndTotalCap(self, gndcap, totalcap, MillerMult)

    def getGndCap(self, gndcap, totalcap):
        return _odb_py.dbCapNode_getGndCap(self, gndcap, totalcap)

    def getGndTotalCap(self, gndcap, totalcap, MillerMult):
        return _odb_py.dbCapNode_getGndTotalCap(self, gndcap, totalcap, MillerMult)

    def accAllCcCap(self, totalcap, MillerMult):
        return _odb_py.dbCapNode_accAllCcCap(self, totalcap, MillerMult)

    def setCapacitance(self, cap, corner=0):
        return _odb_py.dbCapNode_setCapacitance(self, cap, corner)

    def addCapacitance(self, cap, corner=0):
        return _odb_py.dbCapNode_addCapacitance(self, cap, corner)

    def groundCC(self, gndFactor):
        return _odb_py.dbCapNode_groundCC(self, gndFactor)

    def adjustCapacitance(self, *args):
        return _odb_py.dbCapNode_adjustCapacitance(self, *args)

    def needAdjustCC(self, ccThreshHold):
        return _odb_py.dbCapNode_needAdjustCC(self, ccThreshHold)

    def adjustCC(self, adjOrder, adjFactor, adjustedCC, halonets):
        return _odb_py.dbCapNode_adjustCC(self, adjOrder, adjFactor, adjustedCC, halonets)

    def getCapacitance(self, corner=0):
        return _odb_py.dbCapNode_getCapacitance(self, corner)

    def getNode(self):
        return _odb_py.dbCapNode_getNode(self)

    def getShapeId(self):
        return _odb_py.dbCapNode_getShapeId(self)

    def setNode(self, nodeid):
        return _odb_py.dbCapNode_setNode(self, nodeid)

    def isName(self):
        return _odb_py.dbCapNode_isName(self)

    def isITerm(self):
        return _odb_py.dbCapNode_isITerm(self)

    def isBTerm(self):
        return _odb_py.dbCapNode_isBTerm(self)

    def isInternal(self):
        return _odb_py.dbCapNode_isInternal(self)

    def isBranch(self):
        return _odb_py.dbCapNode_isBranch(self)

    def isDangling(self):
        return _odb_py.dbCapNode_isDangling(self)

    def isForeign(self):
        return _odb_py.dbCapNode_isForeign(self)

    def isTreeNode(self):
        return _odb_py.dbCapNode_isTreeNode(self)

    def isSourceTerm(self, mblock=None):
        return _odb_py.dbCapNode_isSourceTerm(self, mblock)

    def isInoutTerm(self, mblock=None):
        return _odb_py.dbCapNode_isInoutTerm(self, mblock)

    def isSelect(self):
        return _odb_py.dbCapNode_isSelect(self)

    def setSelect(self, value):
        return _odb_py.dbCapNode_setSelect(self, value)

    def incrChildrenCnt(self):
        return _odb_py.dbCapNode_incrChildrenCnt(self)

    def getChildrenCnt(self):
        return _odb_py.dbCapNode_getChildrenCnt(self)

    def setChildrenCnt(self, cnt):
        return _odb_py.dbCapNode_setChildrenCnt(self, cnt)

    def setNameFlag(self):
        return _odb_py.dbCapNode_setNameFlag(self)

    def setBTermFlag(self):
        return _odb_py.dbCapNode_setBTermFlag(self)

    def setITermFlag(self):
        return _odb_py.dbCapNode_setITermFlag(self)

    def setInternalFlag(self):
        return _odb_py.dbCapNode_setInternalFlag(self)

    def setBranchFlag(self):
        return _odb_py.dbCapNode_setBranchFlag(self)

    def setForeignFlag(self):
        return _odb_py.dbCapNode_setForeignFlag(self)

    def resetNameFlag(self):
        return _odb_py.dbCapNode_resetNameFlag(self)

    def resetBTermFlag(self):
        return _odb_py.dbCapNode_resetBTermFlag(self)

    def resetITermFlag(self):
        return _odb_py.dbCapNode_resetITermFlag(self)

    def resetInternalFlag(self):
        return _odb_py.dbCapNode_resetInternalFlag(self)

    def resetBranchFlag(self):
        return _odb_py.dbCapNode_resetBranchFlag(self)

    def resetForeignFlag(self):
        return _odb_py.dbCapNode_resetForeignFlag(self)

    def getSortIndex(self):
        return _odb_py.dbCapNode_getSortIndex(self)

    def setSortIndex(self, idx):
        return _odb_py.dbCapNode_setSortIndex(self, idx)

    def getTermCoords(self, mblock=None):
        return _odb_py.dbCapNode_getTermCoords(self, mblock)

    def getITerm(self, mblock=None):
        return _odb_py.dbCapNode_getITerm(self, mblock)

    def getBTerm(self, mblock=None):
        return _odb_py.dbCapNode_getBTerm(self, mblock)

    def printCC(self):
        return _odb_py.dbCapNode_printCC(self)

    def checkCC(self):
        return _odb_py.dbCapNode_checkCC(self)

    def getCCSegs(self):
        return _odb_py.dbCapNode_getCCSegs(self)

    def getNet(self):
        return _odb_py.dbCapNode_getNet(self)

    def setNet(self, netid):
        return _odb_py.dbCapNode_setNet(self, netid)

    def setNext(self, nextid):
        return _odb_py.dbCapNode_setNext(self, nextid)

    @staticmethod
    def create(net, node, foreign):
        return _odb_py.dbCapNode_create(net, node, foreign)

    def addToNet(self):
        return _odb_py.dbCapNode_addToNet(self)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbCapNode_destroy(*args)

    @staticmethod
    def getCapNode(block, oid):
        return _odb_py.dbCapNode_getCapNode(block, oid)

    def __init__(self):
        _odb_py.dbCapNode_swiginit(self, _odb_py.new_dbCapNode())
    __swig_destroy__ = _odb_py.delete_dbCapNode

# Register dbCapNode in _odb_py:
_odb_py.dbCapNode_swigregister(dbCapNode)

def dbCapNode_create(net, node, foreign):
    return _odb_py.dbCapNode_create(net, node, foreign)

def dbCapNode_destroy(*args):
    return _odb_py.dbCapNode_destroy(*args)

def dbCapNode_getCapNode(block, oid):
    return _odb_py.dbCapNode_getCapNode(block, oid)

class dbRSeg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def addRSegResistance(self, other):
        return _odb_py.dbRSeg_addRSegResistance(self, other)

    def addRSegCapacitance(self, other):
        return _odb_py.dbRSeg_addRSegCapacitance(self, other)

    def getResistance(self, corner=0):
        return _odb_py.dbRSeg_getResistance(self, corner)

    def getAllRes(self, res):
        return _odb_py.dbRSeg_getAllRes(self, res)

    def addAllRes(self, res):
        return _odb_py.dbRSeg_addAllRes(self, res)

    def getGndCap(self, gndcap, totalcap):
        return _odb_py.dbRSeg_getGndCap(self, gndcap, totalcap)

    def addGndCap(self, gndcap, totalcap):
        return _odb_py.dbRSeg_addGndCap(self, gndcap, totalcap)

    def getGndTotalCap(self, gndcap, totalcap, MillerMult):
        return _odb_py.dbRSeg_getGndTotalCap(self, gndcap, totalcap, MillerMult)

    def addGndTotalCap(self, gndcap, totalcap, MillerMult):
        return _odb_py.dbRSeg_addGndTotalCap(self, gndcap, totalcap, MillerMult)

    def mergeRCs(self, mrsegs):
        return _odb_py.dbRSeg_mergeRCs(self, mrsegs)

    def adjustSourceCapacitance(self, factor, corner):
        return _odb_py.dbRSeg_adjustSourceCapacitance(self, factor, corner)

    def adjustCapacitance(self, *args):
        return _odb_py.dbRSeg_adjustCapacitance(self, *args)

    def setCapacitance(self, cap, corner=0):
        return _odb_py.dbRSeg_setCapacitance(self, cap, corner)

    def updatedCap(self):
        return _odb_py.dbRSeg_updatedCap(self)

    def getSourceCapacitance(self, corner=0):
        return _odb_py.dbRSeg_getSourceCapacitance(self, corner)

    def getCapacitance(self, *args):
        return _odb_py.dbRSeg_getCapacitance(self, *args)

    def getCcSegs(self, ccsegs):
        return _odb_py.dbRSeg_getCcSegs(self, ccsegs)

    def printCcSegs(self):
        return _odb_py.dbRSeg_printCcSegs(self)

    def printCC(self):
        return _odb_py.dbRSeg_printCC(self)

    def checkCC(self):
        return _odb_py.dbRSeg_checkCC(self)

    def getCapTable(self, cap):
        return _odb_py.dbRSeg_getCapTable(self, cap)

    def setResistance(self, res, corner=0):
        return _odb_py.dbRSeg_setResistance(self, res, corner)

    def adjustResistance(self, *args):
        return _odb_py.dbRSeg_adjustResistance(self, *args)

    def setNext(self, next_id):
        return _odb_py.dbRSeg_setNext(self, next_id)

    def getSourceNode(self):
        return _odb_py.dbRSeg_getSourceNode(self)

    def getSourceCapNode(self):
        return _odb_py.dbRSeg_getSourceCapNode(self)

    def setSourceNode(self, nodeid):
        return _odb_py.dbRSeg_setSourceNode(self, nodeid)

    def getTargetNode(self):
        return _odb_py.dbRSeg_getTargetNode(self)

    def getTargetCapNode(self):
        return _odb_py.dbRSeg_getTargetCapNode(self)

    def setTargetNode(self, nodeid):
        return _odb_py.dbRSeg_setTargetNode(self, nodeid)

    def getShapeId(self):
        return _odb_py.dbRSeg_getShapeId(self)

    def setCoords(self, x, y):
        return _odb_py.dbRSeg_setCoords(self, x, y)

    def getCoords(self):
        return _odb_py.dbRSeg_getCoords(self)

    def updateShapeId(self, nsid):
        return _odb_py.dbRSeg_updateShapeId(self, nsid)

    def pathLowToHigh(self):
        return _odb_py.dbRSeg_pathLowToHigh(self)

    def allocatedCap(self):
        return _odb_py.dbRSeg_allocatedCap(self)

    def getLengthWidth(self, w):
        return _odb_py.dbRSeg_getLengthWidth(self, w)

    def addToNet(self):
        return _odb_py.dbRSeg_addToNet(self)

    def getNet(self):
        return _odb_py.dbRSeg_getNet(self)

    @staticmethod
    def create(net, x, y, path_dir, allocate_cap):
        return _odb_py.dbRSeg_create(net, x, y, path_dir, allocate_cap)

    @staticmethod
    def destroyS(seg):
        return _odb_py.dbRSeg_destroyS(seg)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbRSeg_destroy(*args)

    @staticmethod
    def getRSeg(block, oid):
        return _odb_py.dbRSeg_getRSeg(block, oid)

    def __init__(self):
        _odb_py.dbRSeg_swiginit(self, _odb_py.new_dbRSeg())
    __swig_destroy__ = _odb_py.delete_dbRSeg

# Register dbRSeg in _odb_py:
_odb_py.dbRSeg_swigregister(dbRSeg)

def dbRSeg_create(net, x, y, path_dir, allocate_cap):
    return _odb_py.dbRSeg_create(net, x, y, path_dir, allocate_cap)

def dbRSeg_destroyS(seg):
    return _odb_py.dbRSeg_destroyS(seg)

def dbRSeg_destroy(*args):
    return _odb_py.dbRSeg_destroy(*args)

def dbRSeg_getRSeg(block, oid):
    return _odb_py.dbRSeg_getRSeg(block, oid)

class dbCCSeg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def adjustCapacitance(self, *args):
        return _odb_py.dbCCSeg_adjustCapacitance(self, *args)

    def getCapacitance(self, corner=0):
        return _odb_py.dbCCSeg_getCapacitance(self, corner)

    def setCapacitance(self, cap, corner=0):
        return _odb_py.dbCCSeg_setCapacitance(self, cap, corner)

    def addCapacitance(self, cap, corner=0):
        return _odb_py.dbCCSeg_addCapacitance(self, cap, corner)

    def accAllCcCap(self, ttcap, MillerMult):
        return _odb_py.dbCCSeg_accAllCcCap(self, ttcap, MillerMult)

    def getAllCcCap(self, ttcap):
        return _odb_py.dbCCSeg_getAllCcCap(self, ttcap)

    def setAllCcCap(self, ttcap):
        return _odb_py.dbCCSeg_setAllCcCap(self, ttcap)

    def getSourceCapNode(self):
        return _odb_py.dbCCSeg_getSourceCapNode(self)

    def getTargetCapNode(self):
        return _odb_py.dbCCSeg_getTargetCapNode(self)

    def addCcCapacitance(self, other):
        return _odb_py.dbCCSeg_addCcCapacitance(self, other)

    def swapCapnode(self, orig, newn):
        return _odb_py.dbCCSeg_swapCapnode(self, orig, newn)

    def getTheOtherCapn(self, oneCap, cid):
        return _odb_py.dbCCSeg_getTheOtherCapn(self, oneCap, cid)

    def getSourceNodeNum(self):
        return _odb_py.dbCCSeg_getSourceNodeNum(self)

    def getTargetNodeNum(self):
        return _odb_py.dbCCSeg_getTargetNodeNum(self)

    def getSourceNet(self):
        return _odb_py.dbCCSeg_getSourceNet(self)

    def getTargetNet(self):
        return _odb_py.dbCCSeg_getTargetNet(self)

    def getInfileCnt(self):
        return _odb_py.dbCCSeg_getInfileCnt(self)

    def incrInfileCnt(self):
        return _odb_py.dbCCSeg_incrInfileCnt(self)

    def isMarked(self):
        return _odb_py.dbCCSeg_isMarked(self)

    def setMark(self, value):
        return _odb_py.dbCCSeg_setMark(self, value)

    def printCapnCC(self, capn):
        return _odb_py.dbCCSeg_printCapnCC(self, capn)

    def checkCapnCC(self, capn):
        return _odb_py.dbCCSeg_checkCapnCC(self, capn)

    def unLink_cc_seg(self, capn):
        return _odb_py.dbCCSeg_unLink_cc_seg(self, capn)

    def Link_cc_seg(self, capn, cseq):
        return _odb_py.dbCCSeg_Link_cc_seg(self, capn, cseq)

    @staticmethod
    def findCC(nodeA, nodeB):
        return _odb_py.dbCCSeg_findCC(nodeA, nodeB)

    @staticmethod
    def create(nodeA, nodeB, mergeParallel=False):
        return _odb_py.dbCCSeg_create(nodeA, nodeB, mergeParallel)

    @staticmethod
    def destroyS(seg):
        return _odb_py.dbCCSeg_destroyS(seg)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbCCSeg_destroy(*args)

    @staticmethod
    def getCCSeg(block, oid):
        return _odb_py.dbCCSeg_getCCSeg(block, oid)

    @staticmethod
    def disconnect(tcc_):
        return _odb_py.dbCCSeg_disconnect(tcc_)

    @staticmethod
    def connect(tcc_):
        return _odb_py.dbCCSeg_connect(tcc_)

    def __init__(self):
        _odb_py.dbCCSeg_swiginit(self, _odb_py.new_dbCCSeg())
    __swig_destroy__ = _odb_py.delete_dbCCSeg

# Register dbCCSeg in _odb_py:
_odb_py.dbCCSeg_swigregister(dbCCSeg)

def dbCCSeg_findCC(nodeA, nodeB):
    return _odb_py.dbCCSeg_findCC(nodeA, nodeB)

def dbCCSeg_create(nodeA, nodeB, mergeParallel=False):
    return _odb_py.dbCCSeg_create(nodeA, nodeB, mergeParallel)

def dbCCSeg_destroyS(seg):
    return _odb_py.dbCCSeg_destroyS(seg)

def dbCCSeg_destroy(*args):
    return _odb_py.dbCCSeg_destroy(*args)

def dbCCSeg_getCCSeg(block, oid):
    return _odb_py.dbCCSeg_getCCSeg(block, oid)

def dbCCSeg_disconnect(tcc_):
    return _odb_py.dbCCSeg_disconnect(tcc_)

def dbCCSeg_connect(tcc_):
    return _odb_py.dbCCSeg_connect(tcc_)

class dbRow(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbRow_getName(self)

    def getConstName(self):
        return _odb_py.dbRow_getConstName(self)

    def getSite(self):
        return _odb_py.dbRow_getSite(self)

    def getOrigin(self):
        return _odb_py.dbRow_getOrigin(self)

    def getOrient(self):
        return _odb_py.dbRow_getOrient(self)

    def getDirection(self):
        return _odb_py.dbRow_getDirection(self)

    def getSiteCount(self):
        return _odb_py.dbRow_getSiteCount(self)

    def getSpacing(self):
        return _odb_py.dbRow_getSpacing(self)

    def getBBox(self):
        return _odb_py.dbRow_getBBox(self)

    def getBlock(self):
        return _odb_py.dbRow_getBlock(self)

    @staticmethod
    def create(block, name, site, origin_x, origin_y, orient, direction, num_sites, spacing):
        return _odb_py.dbRow_create(block, name, site, origin_x, origin_y, orient, direction, num_sites, spacing)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbRow_destroy(*args)

    @staticmethod
    def getRow(block, oid):
        return _odb_py.dbRow_getRow(block, oid)

    def __init__(self):
        _odb_py.dbRow_swiginit(self, _odb_py.new_dbRow())
    __swig_destroy__ = _odb_py.delete_dbRow

# Register dbRow in _odb_py:
_odb_py.dbRow_swigregister(dbRow)

def dbRow_create(block, name, site, origin_x, origin_y, orient, direction, num_sites, spacing):
    return _odb_py.dbRow_create(block, name, site, origin_x, origin_y, orient, direction, num_sites, spacing)

def dbRow_destroy(*args):
    return _odb_py.dbRow_destroy(*args)

def dbRow_getRow(block, oid):
    return _odb_py.dbRow_getRow(block, oid)

class dbFill(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getRect(self):
        return _odb_py.dbFill_getRect(self)

    def needsOPC(self):
        return _odb_py.dbFill_needsOPC(self)

    def maskNumber(self):
        return _odb_py.dbFill_maskNumber(self)

    def getTechLayer(self):
        return _odb_py.dbFill_getTechLayer(self)

    @staticmethod
    def create(block, needs_opc, mask_number, layer, x1, y1, x2, y2):
        return _odb_py.dbFill_create(block, needs_opc, mask_number, layer, x1, y1, x2, y2)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbFill_destroy(*args)

    @staticmethod
    def getFill(block, oid):
        return _odb_py.dbFill_getFill(block, oid)

    def __init__(self):
        _odb_py.dbFill_swiginit(self, _odb_py.new_dbFill())
    __swig_destroy__ = _odb_py.delete_dbFill

# Register dbFill in _odb_py:
_odb_py.dbFill_swigregister(dbFill)

def dbFill_create(block, needs_opc, mask_number, layer, x1, y1, x2, y2):
    return _odb_py.dbFill_create(block, needs_opc, mask_number, layer, x1, y1, x2, y2)

def dbFill_destroy(*args):
    return _odb_py.dbFill_destroy(*args)

def dbFill_getFill(block, oid):
    return _odb_py.dbFill_getFill(block, oid)

class dbRegion(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbRegion_getName(self)

    def getRegionType(self):
        return _odb_py.dbRegion_getRegionType(self)

    def setRegionType(self, type):
        return _odb_py.dbRegion_setRegionType(self, type)

    def getRegionInsts(self):
        return _odb_py.dbRegion_getRegionInsts(self)

    def setInvalid(self, v):
        return _odb_py.dbRegion_setInvalid(self, v)

    def isInvalid(self):
        return _odb_py.dbRegion_isInvalid(self)

    def getBoundaries(self):
        return _odb_py.dbRegion_getBoundaries(self)

    def addInst(self, inst):
        return _odb_py.dbRegion_addInst(self, inst)

    def removeInst(self, inst):
        return _odb_py.dbRegion_removeInst(self, inst)

    def removeGroup(self, group):
        return _odb_py.dbRegion_removeGroup(self, group)

    def addGroup(self, group):
        return _odb_py.dbRegion_addGroup(self, group)

    def getGroups(self):
        return _odb_py.dbRegion_getGroups(self)

    def getBlock(self):
        return _odb_py.dbRegion_getBlock(self)

    @staticmethod
    def create(block, name):
        return _odb_py.dbRegion_create(block, name)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbRegion_destroy(*args)

    @staticmethod
    def getRegion(block, oid):
        return _odb_py.dbRegion_getRegion(block, oid)

    def __init__(self):
        _odb_py.dbRegion_swiginit(self, _odb_py.new_dbRegion())
    __swig_destroy__ = _odb_py.delete_dbRegion

# Register dbRegion in _odb_py:
_odb_py.dbRegion_swigregister(dbRegion)

def dbRegion_create(block, name):
    return _odb_py.dbRegion_create(block, name)

def dbRegion_destroy(*args):
    return _odb_py.dbRegion_destroy(*args)

def dbRegion_getRegion(block, oid):
    return _odb_py.dbRegion_getRegion(block, oid)

class dbLib(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbLib_getName(self)

    def getConstName(self):
        return _odb_py.dbLib_getConstName(self)

    def getDbUnitsPerMicron(self):
        return _odb_py.dbLib_getDbUnitsPerMicron(self)

    def getTech(self):
        return _odb_py.dbLib_getTech(self)

    def getMasters(self):
        return _odb_py.dbLib_getMasters(self)

    def findMaster(self, name):
        return _odb_py.dbLib_findMaster(self, name)

    def getSites(self):
        return _odb_py.dbLib_getSites(self)

    def findSite(self, name):
        return _odb_py.dbLib_findSite(self, name)

    def getLefUnits(self):
        return _odb_py.dbLib_getLefUnits(self)

    def setLefUnits(self, units):
        return _odb_py.dbLib_setLefUnits(self, units)

    def getHierarchyDelimeter(self):
        return _odb_py.dbLib_getHierarchyDelimeter(self)

    def setBusDelimeters(self, left, right):
        return _odb_py.dbLib_setBusDelimeters(self, left, right)

    def getBusDelimeters(self, left, right):
        return _odb_py.dbLib_getBusDelimeters(self, left, right)

    @staticmethod
    def create(db, name, tech, hierarchy_delimeter=0):
        return _odb_py.dbLib_create(db, name, tech, hierarchy_delimeter)

    @staticmethod
    def getLib(db, oid):
        return _odb_py.dbLib_getLib(db, oid)

    @staticmethod
    def destroy(lib):
        return _odb_py.dbLib_destroy(lib)

    def __init__(self):
        _odb_py.dbLib_swiginit(self, _odb_py.new_dbLib())
    __swig_destroy__ = _odb_py.delete_dbLib

# Register dbLib in _odb_py:
_odb_py.dbLib_swigregister(dbLib)

def dbLib_create(db, name, tech, hierarchy_delimeter=0):
    return _odb_py.dbLib_create(db, name, tech, hierarchy_delimeter)

def dbLib_getLib(db, oid):
    return _odb_py.dbLib_getLib(db, oid)

def dbLib_destroy(lib):
    return _odb_py.dbLib_destroy(lib)

class dbSite(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbSite_getName(self)

    def getConstName(self):
        return _odb_py.dbSite_getConstName(self)

    def getWidth(self):
        return _odb_py.dbSite_getWidth(self)

    def setWidth(self, width):
        return _odb_py.dbSite_setWidth(self, width)

    def getHeight(self):
        return _odb_py.dbSite_getHeight(self)

    def setHeight(self, height):
        return _odb_py.dbSite_setHeight(self, height)

    def getClass(self):
        return _odb_py.dbSite_getClass(self)

    def setClass(self, site_class):
        return _odb_py.dbSite_setClass(self, site_class)

    def setSymmetryX(self):
        return _odb_py.dbSite_setSymmetryX(self)

    def getSymmetryX(self):
        return _odb_py.dbSite_getSymmetryX(self)

    def setSymmetryY(self):
        return _odb_py.dbSite_setSymmetryY(self)

    def getSymmetryY(self):
        return _odb_py.dbSite_getSymmetryY(self)

    def setSymmetryR90(self):
        return _odb_py.dbSite_setSymmetryR90(self)

    def getSymmetryR90(self):
        return _odb_py.dbSite_getSymmetryR90(self)

    def setRowPattern(self, row_pattern):
        return _odb_py.dbSite_setRowPattern(self, row_pattern)

    def hasRowPattern(self):
        return _odb_py.dbSite_hasRowPattern(self)

    def isHybrid(self):
        return _odb_py.dbSite_isHybrid(self)

    def getRowPattern(self):
        return _odb_py.dbSite_getRowPattern(self)

    def getLib(self):
        return _odb_py.dbSite_getLib(self)

    @staticmethod
    def create(lib, name):
        return _odb_py.dbSite_create(lib, name)

    @staticmethod
    def getSite(lib, oid):
        return _odb_py.dbSite_getSite(lib, oid)

    def __init__(self):
        _odb_py.dbSite_swiginit(self, _odb_py.new_dbSite())
    __swig_destroy__ = _odb_py.delete_dbSite

# Register dbSite in _odb_py:
_odb_py.dbSite_swigregister(dbSite)

def dbSite_create(lib, name):
    return _odb_py.dbSite_create(lib, name)

def dbSite_getSite(lib, oid):
    return _odb_py.dbSite_getSite(lib, oid)

class dbMaster(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbMaster_getName(self)

    def getConstName(self):
        return _odb_py.dbMaster_getConstName(self)

    def getOrigin(self):
        return _odb_py.dbMaster_getOrigin(self)

    def setOrigin(self, x, y):
        return _odb_py.dbMaster_setOrigin(self, x, y)

    def getWidth(self):
        return _odb_py.dbMaster_getWidth(self)

    def setWidth(self, width):
        return _odb_py.dbMaster_setWidth(self, width)

    def getHeight(self):
        return _odb_py.dbMaster_getHeight(self)

    def setHeight(self, height):
        return _odb_py.dbMaster_setHeight(self, height)

    def isFiller(self):
        return _odb_py.dbMaster_isFiller(self)

    def getType(self):
        return _odb_py.dbMaster_getType(self)

    def isBlock(self):
        return _odb_py.dbMaster_isBlock(self)

    def isCore(self):
        return _odb_py.dbMaster_isCore(self)

    def isPad(self):
        return _odb_py.dbMaster_isPad(self)

    def isEndCap(self):
        return _odb_py.dbMaster_isEndCap(self)

    def isCover(self):
        return _odb_py.dbMaster_isCover(self)

    def isCoreAutoPlaceable(self):
        return _odb_py.dbMaster_isCoreAutoPlaceable(self)

    def setType(self, type):
        return _odb_py.dbMaster_setType(self, type)

    def getLEQ(self):
        return _odb_py.dbMaster_getLEQ(self)

    def setLEQ(self, master):
        return _odb_py.dbMaster_setLEQ(self, master)

    def getEEQ(self):
        return _odb_py.dbMaster_getEEQ(self)

    def setEEQ(self, master):
        return _odb_py.dbMaster_setEEQ(self, master)

    def setSymmetryX(self):
        return _odb_py.dbMaster_setSymmetryX(self)

    def getSymmetryX(self):
        return _odb_py.dbMaster_getSymmetryX(self)

    def setSymmetryY(self):
        return _odb_py.dbMaster_setSymmetryY(self)

    def getSymmetryY(self):
        return _odb_py.dbMaster_getSymmetryY(self)

    def setSymmetryR90(self):
        return _odb_py.dbMaster_setSymmetryR90(self)

    def getSymmetryR90(self):
        return _odb_py.dbMaster_getSymmetryR90(self)

    def getMTerms(self):
        return _odb_py.dbMaster_getMTerms(self)

    def findMTerm(self, *args):
        return _odb_py.dbMaster_findMTerm(self, *args)

    def getLib(self):
        return _odb_py.dbMaster_getLib(self)

    def getObstructions(self):
        return _odb_py.dbMaster_getObstructions(self)

    def getPlacementBoundary(self):
        return _odb_py.dbMaster_getPlacementBoundary(self)

    def transform(self, t):
        return _odb_py.dbMaster_transform(self, t)

    def setFrozen(self):
        return _odb_py.dbMaster_setFrozen(self)

    def isFrozen(self):
        return _odb_py.dbMaster_isFrozen(self)

    def setSequential(self, v):
        return _odb_py.dbMaster_setSequential(self, v)

    def isSequential(self):
        return _odb_py.dbMaster_isSequential(self)

    def setMark(self, mark):
        return _odb_py.dbMaster_setMark(self, mark)

    def isMarked(self):
        return _odb_py.dbMaster_isMarked(self)

    def isSpecialPower(self):
        return _odb_py.dbMaster_isSpecialPower(self)

    def setSpecialPower(self, v):
        return _odb_py.dbMaster_setSpecialPower(self, v)

    def getMTermCount(self):
        return _odb_py.dbMaster_getMTermCount(self)

    def setSite(self, site):
        return _odb_py.dbMaster_setSite(self, site)

    def getSite(self):
        return _odb_py.dbMaster_getSite(self)

    def getMasterId(self):
        return _odb_py.dbMaster_getMasterId(self)

    @staticmethod
    def create(lib, name):
        return _odb_py.dbMaster_create(lib, name)

    @staticmethod
    def destroy(master):
        return _odb_py.dbMaster_destroy(master)

    @staticmethod
    def getMaster(lib, oid):
        return _odb_py.dbMaster_getMaster(lib, oid)

    def staCell(self):
        return _odb_py.dbMaster_staCell(self)

    def staSetCell(self, cell):
        return _odb_py.dbMaster_staSetCell(self, cell)

    def __init__(self):
        _odb_py.dbMaster_swiginit(self, _odb_py.new_dbMaster())
    __swig_destroy__ = _odb_py.delete_dbMaster

# Register dbMaster in _odb_py:
_odb_py.dbMaster_swigregister(dbMaster)

def dbMaster_create(lib, name):
    return _odb_py.dbMaster_create(lib, name)

def dbMaster_destroy(master):
    return _odb_py.dbMaster_destroy(master)

def dbMaster_getMaster(lib, oid):
    return _odb_py.dbMaster_getMaster(lib, oid)

class dbMTerm(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getConstName(self):
        return _odb_py.dbMTerm_getConstName(self)

    def getName(self, *args):
        return _odb_py.dbMTerm_getName(self, *args)

    def getSigType(self):
        return _odb_py.dbMTerm_getSigType(self)

    def getIoType(self):
        return _odb_py.dbMTerm_getIoType(self)

    def getShape(self):
        return _odb_py.dbMTerm_getShape(self)

    def setMark(self, v):
        return _odb_py.dbMTerm_setMark(self, v)

    def isSetMark(self):
        return _odb_py.dbMTerm_isSetMark(self)

    def getMaster(self):
        return _odb_py.dbMTerm_getMaster(self)

    def getMPins(self):
        return _odb_py.dbMTerm_getMPins(self)

    def getBBox(self):
        return _odb_py.dbMTerm_getBBox(self)

    def getTargets(self):
        return _odb_py.dbMTerm_getTargets(self)

    def addPartialMetalAreaEntry(self, inval, refly=None):
        return _odb_py.dbMTerm_addPartialMetalAreaEntry(self, inval, refly)

    def addPartialMetalSideAreaEntry(self, inval, refly=None):
        return _odb_py.dbMTerm_addPartialMetalSideAreaEntry(self, inval, refly)

    def addPartialCutAreaEntry(self, inval, refly=None):
        return _odb_py.dbMTerm_addPartialCutAreaEntry(self, inval, refly)

    def addDiffAreaEntry(self, inval, refly=None):
        return _odb_py.dbMTerm_addDiffAreaEntry(self, inval, refly)

    def createDefaultAntennaModel(self):
        return _odb_py.dbMTerm_createDefaultAntennaModel(self)

    def createOxide2AntennaModel(self):
        return _odb_py.dbMTerm_createOxide2AntennaModel(self)

    def hasDefaultAntennaModel(self):
        return _odb_py.dbMTerm_hasDefaultAntennaModel(self)

    def hasOxide2AntennaModel(self):
        return _odb_py.dbMTerm_hasOxide2AntennaModel(self)

    def getDefaultAntennaModel(self):
        return _odb_py.dbMTerm_getDefaultAntennaModel(self)

    def getOxide2AntennaModel(self):
        return _odb_py.dbMTerm_getOxide2AntennaModel(self)

    def writeAntennaLef(self, writer):
        return _odb_py.dbMTerm_writeAntennaLef(self, writer)

    def getDiffArea(self):
        return _odb_py.dbMTerm_getDiffArea(self)

    def staPort(self):
        return _odb_py.dbMTerm_staPort(self)

    def staSetPort(self, port):
        return _odb_py.dbMTerm_staSetPort(self, port)

    def getIndex(self):
        return _odb_py.dbMTerm_getIndex(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbMTerm_create(*args)

    @staticmethod
    def getMTerm(master, oid):
        return _odb_py.dbMTerm_getMTerm(master, oid)

    def __init__(self):
        _odb_py.dbMTerm_swiginit(self, _odb_py.new_dbMTerm())
    __swig_destroy__ = _odb_py.delete_dbMTerm

# Register dbMTerm in _odb_py:
_odb_py.dbMTerm_swigregister(dbMTerm)

def dbMTerm_create(*args):
    return _odb_py.dbMTerm_create(*args)

def dbMTerm_getMTerm(master, oid):
    return _odb_py.dbMTerm_getMTerm(master, oid)

class dbMPin(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getMTerm(self):
        return _odb_py.dbMPin_getMTerm(self)

    def getMaster(self):
        return _odb_py.dbMPin_getMaster(self)

    def getGeometry(self):
        return _odb_py.dbMPin_getGeometry(self)

    def getBBox(self):
        return _odb_py.dbMPin_getBBox(self)

    def getPinAccess(self):
        return _odb_py.dbMPin_getPinAccess(self)

    @staticmethod
    def create(mterm):
        return _odb_py.dbMPin_create(mterm)

    @staticmethod
    def getMPin(master, oid):
        return _odb_py.dbMPin_getMPin(master, oid)

    def __init__(self):
        _odb_py.dbMPin_swiginit(self, _odb_py.new_dbMPin())
    __swig_destroy__ = _odb_py.delete_dbMPin

# Register dbMPin in _odb_py:
_odb_py.dbMPin_swigregister(dbMPin)

def dbMPin_create(mterm):
    return _odb_py.dbMPin_create(mterm)

def dbMPin_getMPin(master, oid):
    return _odb_py.dbMPin_getMPin(master, oid)

class dbTarget(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getMaster(self):
        return _odb_py.dbTarget_getMaster(self)

    def getMTerm(self):
        return _odb_py.dbTarget_getMTerm(self)

    def getTechLayer(self):
        return _odb_py.dbTarget_getTechLayer(self)

    def getPoint(self):
        return _odb_py.dbTarget_getPoint(self)

    @staticmethod
    def create(mterm, layer, point):
        return _odb_py.dbTarget_create(mterm, layer, point)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbTarget_destroy(*args)

    @staticmethod
    def getTarget(master, oid):
        return _odb_py.dbTarget_getTarget(master, oid)

    def __init__(self):
        _odb_py.dbTarget_swiginit(self, _odb_py.new_dbTarget())
    __swig_destroy__ = _odb_py.delete_dbTarget

# Register dbTarget in _odb_py:
_odb_py.dbTarget_swigregister(dbTarget)

def dbTarget_create(mterm, layer, point):
    return _odb_py.dbTarget_create(mterm, layer, point)

def dbTarget_destroy(*args):
    return _odb_py.dbTarget_destroy(*args)

def dbTarget_getTarget(master, oid):
    return _odb_py.dbTarget_getTarget(master, oid)

class dbTech(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbTech_getName(self)

    def setDbUnitsPerMicron(self, value):
        return _odb_py.dbTech_setDbUnitsPerMicron(self, value)

    def getDbUnitsPerMicron(self):
        return _odb_py.dbTech_getDbUnitsPerMicron(self)

    def getLayers(self):
        return _odb_py.dbTech_getLayers(self)

    def findLayer(self, *args):
        return _odb_py.dbTech_findLayer(self, *args)

    def findRoutingLayer(self, level_number):
        return _odb_py.dbTech_findRoutingLayer(self, level_number)

    def getVias(self):
        return _odb_py.dbTech_getVias(self)

    def findVia(self, name):
        return _odb_py.dbTech_findVia(self, name)

    def getLefUnits(self):
        return _odb_py.dbTech_getLefUnits(self)

    def setLefUnits(self, units):
        return _odb_py.dbTech_setLefUnits(self, units)

    def getLefVersion(self):
        return _odb_py.dbTech_getLefVersion(self)

    def getLefVersionStr(self):
        return _odb_py.dbTech_getLefVersionStr(self)

    def setLefVersion(self, inver):
        return _odb_py.dbTech_setLefVersion(self, inver)

    def hasNoWireExtAtPin(self):
        return _odb_py.dbTech_hasNoWireExtAtPin(self)

    def getNoWireExtAtPin(self):
        return _odb_py.dbTech_getNoWireExtAtPin(self)

    def setNoWireExtAtPin(self, intyp):
        return _odb_py.dbTech_setNoWireExtAtPin(self, intyp)

    def getNamesCaseSensitive(self):
        return _odb_py.dbTech_getNamesCaseSensitive(self)

    def setNamesCaseSensitive(self, intyp):
        return _odb_py.dbTech_setNamesCaseSensitive(self, intyp)

    def hasClearanceMeasure(self):
        return _odb_py.dbTech_hasClearanceMeasure(self)

    def getClearanceMeasure(self):
        return _odb_py.dbTech_getClearanceMeasure(self)

    def setClearanceMeasure(self, inmeas):
        return _odb_py.dbTech_setClearanceMeasure(self, inmeas)

    def hasUseMinSpacingObs(self):
        return _odb_py.dbTech_hasUseMinSpacingObs(self)

    def getUseMinSpacingObs(self):
        return _odb_py.dbTech_getUseMinSpacingObs(self)

    def setUseMinSpacingObs(self, inval):
        return _odb_py.dbTech_setUseMinSpacingObs(self, inval)

    def hasUseMinSpacingPin(self):
        return _odb_py.dbTech_hasUseMinSpacingPin(self)

    def getUseMinSpacingPin(self):
        return _odb_py.dbTech_getUseMinSpacingPin(self)

    def setUseMinSpacingPin(self, inval):
        return _odb_py.dbTech_setUseMinSpacingPin(self, inval)

    def hasManufacturingGrid(self):
        return _odb_py.dbTech_hasManufacturingGrid(self)

    def getManufacturingGrid(self):
        return _odb_py.dbTech_getManufacturingGrid(self)

    def setManufacturingGrid(self, ingrd):
        return _odb_py.dbTech_setManufacturingGrid(self, ingrd)

    def getLayerCount(self):
        return _odb_py.dbTech_getLayerCount(self)

    def getRoutingLayerCount(self):
        return _odb_py.dbTech_getRoutingLayerCount(self)

    def getViaCount(self):
        return _odb_py.dbTech_getViaCount(self)

    def getNonDefaultRules(self):
        return _odb_py.dbTech_getNonDefaultRules(self)

    def findNonDefaultRule(self, rulename):
        return _odb_py.dbTech_findNonDefaultRule(self, rulename)

    def findSameNetRule(self, l1, l2):
        return _odb_py.dbTech_findSameNetRule(self, l1, l2)

    def getSameNetRules(self, rules):
        return _odb_py.dbTech_getSameNetRules(self, rules)

    def getViaRules(self):
        return _odb_py.dbTech_getViaRules(self)

    def getViaGenerateRules(self):
        return _odb_py.dbTech_getViaGenerateRules(self)

    def getMetalWidthViaMap(self):
        return _odb_py.dbTech_getMetalWidthViaMap(self)

    def findViaRule(self, name):
        return _odb_py.dbTech_findViaRule(self, name)

    def findViaGenerateRule(self, name):
        return _odb_py.dbTech_findViaGenerateRule(self, name)

    def checkLayer(self, typeChk, widthChk, pitchChk, spacingChk):
        return _odb_py.dbTech_checkLayer(self, typeChk, widthChk, pitchChk, spacingChk)

    @staticmethod
    def create(db, name, dbu_per_micron=1000):
        return _odb_py.dbTech_create(db, name, dbu_per_micron)

    @staticmethod
    def getTech(db, oid):
        return _odb_py.dbTech_getTech(db, oid)

    @staticmethod
    def destroy(tech):
        return _odb_py.dbTech_destroy(tech)

    def __init__(self):
        _odb_py.dbTech_swiginit(self, _odb_py.new_dbTech())
    __swig_destroy__ = _odb_py.delete_dbTech

# Register dbTech in _odb_py:
_odb_py.dbTech_swigregister(dbTech)

def dbTech_create(db, name, dbu_per_micron=1000):
    return _odb_py.dbTech_create(db, name, dbu_per_micron)

def dbTech_getTech(db, oid):
    return _odb_py.dbTech_getTech(db, oid)

def dbTech_destroy(tech):
    return _odb_py.dbTech_destroy(tech)

class dbTechVia(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbTechVia_getName(self)

    def getConstName(self):
        return _odb_py.dbTechVia_getConstName(self)

    def isDefault(self):
        return _odb_py.dbTechVia_isDefault(self)

    def setDefault(self):
        return _odb_py.dbTechVia_setDefault(self)

    def isTopOfStack(self):
        return _odb_py.dbTechVia_isTopOfStack(self)

    def setTopOfStack(self):
        return _odb_py.dbTechVia_setTopOfStack(self)

    def getResistance(self):
        return _odb_py.dbTechVia_getResistance(self)

    def setResistance(self, res):
        return _odb_py.dbTechVia_setResistance(self, res)

    def setPattern(self, pattern):
        return _odb_py.dbTechVia_setPattern(self, pattern)

    def getPattern(self):
        return _odb_py.dbTechVia_getPattern(self)

    def setViaGenerateRule(self, rule):
        return _odb_py.dbTechVia_setViaGenerateRule(self, rule)

    def getViaGenerateRule(self):
        return _odb_py.dbTechVia_getViaGenerateRule(self)

    def hasParams(self):
        return _odb_py.dbTechVia_hasParams(self)

    def setViaParams(self, params):
        return _odb_py.dbTechVia_setViaParams(self, params)

    def getViaParams(self):
        return _odb_py.dbTechVia_getViaParams(self)

    def getTech(self):
        return _odb_py.dbTechVia_getTech(self)

    def getBBox(self):
        return _odb_py.dbTechVia_getBBox(self)

    def getBoxes(self):
        return _odb_py.dbTechVia_getBoxes(self)

    def getTopLayer(self):
        return _odb_py.dbTechVia_getTopLayer(self)

    def getBottomLayer(self):
        return _odb_py.dbTechVia_getBottomLayer(self)

    def getNonDefaultRule(self):
        return _odb_py.dbTechVia_getNonDefaultRule(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbTechVia_create(*args)

    @staticmethod
    def clone(rule, invia_, new_name):
        return _odb_py.dbTechVia_clone(rule, invia_, new_name)

    @staticmethod
    def getTechVia(tech, oid):
        return _odb_py.dbTechVia_getTechVia(tech, oid)

    def __init__(self):
        _odb_py.dbTechVia_swiginit(self, _odb_py.new_dbTechVia())
    __swig_destroy__ = _odb_py.delete_dbTechVia

# Register dbTechVia in _odb_py:
_odb_py.dbTechVia_swigregister(dbTechVia)

def dbTechVia_create(*args):
    return _odb_py.dbTechVia_create(*args)

def dbTechVia_clone(rule, invia_, new_name):
    return _odb_py.dbTechVia_clone(rule, invia_, new_name)

def dbTechVia_getTechVia(tech, oid):
    return _odb_py.dbTechVia_getTechVia(tech, oid)

class dbTechViaRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbTechViaRule_getName(self)

    def addVia(self, via):
        return _odb_py.dbTechViaRule_addVia(self, via)

    def getViaCount(self):
        return _odb_py.dbTechViaRule_getViaCount(self)

    def getVia(self, indx):
        return _odb_py.dbTechViaRule_getVia(self, indx)

    def getViaLayerRuleCount(self):
        return _odb_py.dbTechViaRule_getViaLayerRuleCount(self)

    def getViaLayerRule(self, indx):
        return _odb_py.dbTechViaRule_getViaLayerRule(self, indx)

    @staticmethod
    def create(tech, name):
        return _odb_py.dbTechViaRule_create(tech, name)

    @staticmethod
    def getTechViaRule(tech, oid):
        return _odb_py.dbTechViaRule_getTechViaRule(tech, oid)

    def __init__(self):
        _odb_py.dbTechViaRule_swiginit(self, _odb_py.new_dbTechViaRule())
    __swig_destroy__ = _odb_py.delete_dbTechViaRule

# Register dbTechViaRule in _odb_py:
_odb_py.dbTechViaRule_swigregister(dbTechViaRule)

def dbTechViaRule_create(tech, name):
    return _odb_py.dbTechViaRule_create(tech, name)

def dbTechViaRule_getTechViaRule(tech, oid):
    return _odb_py.dbTechViaRule_getTechViaRule(tech, oid)

class dbTechViaLayerRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getLayer(self):
        return _odb_py.dbTechViaLayerRule_getLayer(self)

    def getDirection(self):
        return _odb_py.dbTechViaLayerRule_getDirection(self)

    def setDirection(self, dir):
        return _odb_py.dbTechViaLayerRule_setDirection(self, dir)

    def hasWidth(self):
        return _odb_py.dbTechViaLayerRule_hasWidth(self)

    def getWidth(self, minWidth, maxWidth):
        return _odb_py.dbTechViaLayerRule_getWidth(self, minWidth, maxWidth)

    def setWidth(self, minWidth, maxWidth):
        return _odb_py.dbTechViaLayerRule_setWidth(self, minWidth, maxWidth)

    def hasEnclosure(self):
        return _odb_py.dbTechViaLayerRule_hasEnclosure(self)

    def getEnclosure(self):
        return _odb_py.dbTechViaLayerRule_getEnclosure(self)

    def setEnclosure(self, overhang1, overhang2):
        return _odb_py.dbTechViaLayerRule_setEnclosure(self, overhang1, overhang2)

    def hasOverhang(self):
        return _odb_py.dbTechViaLayerRule_hasOverhang(self)

    def getOverhang(self):
        return _odb_py.dbTechViaLayerRule_getOverhang(self)

    def setOverhang(self, overhang):
        return _odb_py.dbTechViaLayerRule_setOverhang(self, overhang)

    def hasMetalOverhang(self):
        return _odb_py.dbTechViaLayerRule_hasMetalOverhang(self)

    def getMetalOverhang(self):
        return _odb_py.dbTechViaLayerRule_getMetalOverhang(self)

    def setMetalOverhang(self, overhang):
        return _odb_py.dbTechViaLayerRule_setMetalOverhang(self, overhang)

    def hasRect(self):
        return _odb_py.dbTechViaLayerRule_hasRect(self)

    def getRect(self):
        return _odb_py.dbTechViaLayerRule_getRect(self)

    def setRect(self):
        return _odb_py.dbTechViaLayerRule_setRect(self)

    def hasSpacing(self):
        return _odb_py.dbTechViaLayerRule_hasSpacing(self)

    def getSpacing(self):
        return _odb_py.dbTechViaLayerRule_getSpacing(self)

    def setSpacing(self, x_spacing, y_spacing):
        return _odb_py.dbTechViaLayerRule_setSpacing(self, x_spacing, y_spacing)

    def hasResistance(self):
        return _odb_py.dbTechViaLayerRule_hasResistance(self)

    def setResistance(self, r):
        return _odb_py.dbTechViaLayerRule_setResistance(self, r)

    def getResistance(self):
        return _odb_py.dbTechViaLayerRule_getResistance(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbTechViaLayerRule_create(*args)

    @staticmethod
    def getTechViaLayerRule(tech, oid):
        return _odb_py.dbTechViaLayerRule_getTechViaLayerRule(tech, oid)

    def __init__(self):
        _odb_py.dbTechViaLayerRule_swiginit(self, _odb_py.new_dbTechViaLayerRule())
    __swig_destroy__ = _odb_py.delete_dbTechViaLayerRule

# Register dbTechViaLayerRule in _odb_py:
_odb_py.dbTechViaLayerRule_swigregister(dbTechViaLayerRule)

def dbTechViaLayerRule_create(*args):
    return _odb_py.dbTechViaLayerRule_create(*args)

def dbTechViaLayerRule_getTechViaLayerRule(tech, oid):
    return _odb_py.dbTechViaLayerRule_getTechViaLayerRule(tech, oid)

class dbTechViaGenerateRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbTechViaGenerateRule_getName(self)

    def isDefault(self):
        return _odb_py.dbTechViaGenerateRule_isDefault(self)

    def getViaLayerRuleCount(self):
        return _odb_py.dbTechViaGenerateRule_getViaLayerRuleCount(self)

    def getViaLayerRule(self, indx):
        return _odb_py.dbTechViaGenerateRule_getViaLayerRule(self, indx)

    @staticmethod
    def create(tech, name, is_default):
        return _odb_py.dbTechViaGenerateRule_create(tech, name, is_default)

    @staticmethod
    def getTechViaGenerateRule(tech, oid):
        return _odb_py.dbTechViaGenerateRule_getTechViaGenerateRule(tech, oid)

    def __init__(self):
        _odb_py.dbTechViaGenerateRule_swiginit(self, _odb_py.new_dbTechViaGenerateRule())
    __swig_destroy__ = _odb_py.delete_dbTechViaGenerateRule

# Register dbTechViaGenerateRule in _odb_py:
_odb_py.dbTechViaGenerateRule_swigregister(dbTechViaGenerateRule)

def dbTechViaGenerateRule_create(tech, name, is_default):
    return _odb_py.dbTechViaGenerateRule_create(tech, name, is_default)

def dbTechViaGenerateRule_getTechViaGenerateRule(tech, oid):
    return _odb_py.dbTechViaGenerateRule_getTechViaGenerateRule(tech, oid)

class dbTechLayerSpacingRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def isUnconditional(self):
        return _odb_py.dbTechLayerSpacingRule_isUnconditional(self)

    def getSpacing(self):
        return _odb_py.dbTechLayerSpacingRule_getSpacing(self)

    def getLengthThreshold(self, threshold):
        return _odb_py.dbTechLayerSpacingRule_getLengthThreshold(self, threshold)

    def getLengthThresholdRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_getLengthThresholdRange(self, rmin, rmax)

    def getRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_getRange(self, rmin, rmax)

    def setSpacingNotchLengthValid(self, val):
        return _odb_py.dbTechLayerSpacingRule_setSpacingNotchLengthValid(self, val)

    def setSpacingEndOfNotchWidthValid(self, val):
        return _odb_py.dbTechLayerSpacingRule_setSpacingEndOfNotchWidthValid(self, val)

    def hasSpacingNotchLength(self):
        return _odb_py.dbTechLayerSpacingRule_hasSpacingNotchLength(self)

    def hasSpacingEndOfNotchWidth(self):
        return _odb_py.dbTechLayerSpacingRule_hasSpacingEndOfNotchWidth(self)

    def hasRange(self):
        return _odb_py.dbTechLayerSpacingRule_hasRange(self)

    def hasLengthThreshold(self):
        return _odb_py.dbTechLayerSpacingRule_hasLengthThreshold(self)

    def hasUseLengthThreshold(self):
        return _odb_py.dbTechLayerSpacingRule_hasUseLengthThreshold(self)

    def getInfluence(self, influence):
        return _odb_py.dbTechLayerSpacingRule_getInfluence(self, influence)

    def getInfluenceRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_getInfluenceRange(self, rmin, rmax)

    def getRangeRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_getRangeRange(self, rmin, rmax)

    def getAdjacentCuts(self, numcuts, within, spacing, except_same_pgnet):
        return _odb_py.dbTechLayerSpacingRule_getAdjacentCuts(self, numcuts, within, spacing, except_same_pgnet)

    def getCutLayer4Spacing(self, outly):
        return _odb_py.dbTechLayerSpacingRule_getCutLayer4Spacing(self, outly)

    def getCutStacking(self):
        return _odb_py.dbTechLayerSpacingRule_getCutStacking(self)

    def getCutCenterToCenter(self):
        return _odb_py.dbTechLayerSpacingRule_getCutCenterToCenter(self)

    def getCutSameNet(self):
        return _odb_py.dbTechLayerSpacingRule_getCutSameNet(self)

    def getCutParallelOverlap(self):
        return _odb_py.dbTechLayerSpacingRule_getCutParallelOverlap(self)

    def getCutArea(self):
        return _odb_py.dbTechLayerSpacingRule_getCutArea(self)

    def writeLef(self, writer):
        return _odb_py.dbTechLayerSpacingRule_writeLef(self, writer)

    def setSameNetPgOnly(self, pgonly):
        return _odb_py.dbTechLayerSpacingRule_setSameNetPgOnly(self, pgonly)

    def getSameNetPgOnly(self):
        return _odb_py.dbTechLayerSpacingRule_getSameNetPgOnly(self)

    def setLengthThreshold(self, threshold):
        return _odb_py.dbTechLayerSpacingRule_setLengthThreshold(self, threshold)

    def setSpacing(self, spacing):
        return _odb_py.dbTechLayerSpacingRule_setSpacing(self, spacing)

    def setLengthThresholdRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_setLengthThresholdRange(self, rmin, rmax)

    def setRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_setRange(self, rmin, rmax)

    def setUseLengthThreshold(self):
        return _odb_py.dbTechLayerSpacingRule_setUseLengthThreshold(self)

    def setInfluence(self, influence):
        return _odb_py.dbTechLayerSpacingRule_setInfluence(self, influence)

    def setInfluenceRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_setInfluenceRange(self, rmin, rmax)

    def setRangeRange(self, rmin, rmax):
        return _odb_py.dbTechLayerSpacingRule_setRangeRange(self, rmin, rmax)

    def setAdjacentCuts(self, numcuts, within, spacing, except_same_pgnet):
        return _odb_py.dbTechLayerSpacingRule_setAdjacentCuts(self, numcuts, within, spacing, except_same_pgnet)

    def setCutLayer4Spacing(self, cutly):
        return _odb_py.dbTechLayerSpacingRule_setCutLayer4Spacing(self, cutly)

    def setCutStacking(self, stacking):
        return _odb_py.dbTechLayerSpacingRule_setCutStacking(self, stacking)

    def setCutCenterToCenter(self, c2c):
        return _odb_py.dbTechLayerSpacingRule_setCutCenterToCenter(self, c2c)

    def setCutSameNet(self, same_net):
        return _odb_py.dbTechLayerSpacingRule_setCutSameNet(self, same_net)

    def setCutParallelOverlap(self, overlap):
        return _odb_py.dbTechLayerSpacingRule_setCutParallelOverlap(self, overlap)

    def setCutArea(self, area):
        return _odb_py.dbTechLayerSpacingRule_setCutArea(self, area)

    def setEol(self, width, within, parallelEdge, parallelSpace, parallelWithin, twoEdges):
        return _odb_py.dbTechLayerSpacingRule_setEol(self, width, within, parallelEdge, parallelSpace, parallelWithin, twoEdges)

    def getEol(self, width, within, parallelEdge, parallelSpace, parallelWithin, twoEdges):
        return _odb_py.dbTechLayerSpacingRule_getEol(self, width, within, parallelEdge, parallelSpace, parallelWithin, twoEdges)

    @staticmethod
    def create(inly):
        return _odb_py.dbTechLayerSpacingRule_create(inly)

    @staticmethod
    def getTechLayerSpacingRule(inly, dbid):
        return _odb_py.dbTechLayerSpacingRule_getTechLayerSpacingRule(inly, dbid)

    def __init__(self):
        _odb_py.dbTechLayerSpacingRule_swiginit(self, _odb_py.new_dbTechLayerSpacingRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerSpacingRule

# Register dbTechLayerSpacingRule in _odb_py:
_odb_py.dbTechLayerSpacingRule_swigregister(dbTechLayerSpacingRule)

def dbTechLayerSpacingRule_create(inly):
    return _odb_py.dbTechLayerSpacingRule_create(inly)

def dbTechLayerSpacingRule_getTechLayerSpacingRule(inly, dbid):
    return _odb_py.dbTechLayerSpacingRule_getTechLayerSpacingRule(inly, dbid)

class dbTechMinCutRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getMinimumCuts(self, numcuts, width):
        return _odb_py.dbTechMinCutRule_getMinimumCuts(self, numcuts, width)

    def setMinimumCuts(self, numcuts, width, above_only, below_only):
        return _odb_py.dbTechMinCutRule_setMinimumCuts(self, numcuts, width, above_only, below_only)

    def getCutDistance(self, cut_distance):
        return _odb_py.dbTechMinCutRule_getCutDistance(self, cut_distance)

    def setCutDistance(self, cut_distance):
        return _odb_py.dbTechMinCutRule_setCutDistance(self, cut_distance)

    def getLengthForCuts(self, length, distance):
        return _odb_py.dbTechMinCutRule_getLengthForCuts(self, length, distance)

    def setLengthForCuts(self, length, distance):
        return _odb_py.dbTechMinCutRule_setLengthForCuts(self, length, distance)

    def isAboveOnly(self):
        return _odb_py.dbTechMinCutRule_isAboveOnly(self)

    def isBelowOnly(self):
        return _odb_py.dbTechMinCutRule_isBelowOnly(self)

    def writeLef(self, writer):
        return _odb_py.dbTechMinCutRule_writeLef(self, writer)

    @staticmethod
    def create(inly):
        return _odb_py.dbTechMinCutRule_create(inly)

    @staticmethod
    def getMinCutRule(inly, dbid):
        return _odb_py.dbTechMinCutRule_getMinCutRule(inly, dbid)

    def __init__(self):
        _odb_py.dbTechMinCutRule_swiginit(self, _odb_py.new_dbTechMinCutRule())
    __swig_destroy__ = _odb_py.delete_dbTechMinCutRule

# Register dbTechMinCutRule in _odb_py:
_odb_py.dbTechMinCutRule_swigregister(dbTechMinCutRule)

def dbTechMinCutRule_create(inly):
    return _odb_py.dbTechMinCutRule_create(inly)

def dbTechMinCutRule_getMinCutRule(inly, dbid):
    return _odb_py.dbTechMinCutRule_getMinCutRule(inly, dbid)

class dbTechMinEncRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getEnclosure(self, area):
        return _odb_py.dbTechMinEncRule_getEnclosure(self, area)

    def setEnclosure(self, area):
        return _odb_py.dbTechMinEncRule_setEnclosure(self, area)

    def getEnclosureWidth(self, width):
        return _odb_py.dbTechMinEncRule_getEnclosureWidth(self, width)

    def setEnclosureWidth(self, width):
        return _odb_py.dbTechMinEncRule_setEnclosureWidth(self, width)

    def writeLef(self, writer):
        return _odb_py.dbTechMinEncRule_writeLef(self, writer)

    @staticmethod
    def create(inly):
        return _odb_py.dbTechMinEncRule_create(inly)

    @staticmethod
    def getMinEncRule(inly, dbid):
        return _odb_py.dbTechMinEncRule_getMinEncRule(inly, dbid)

    def __init__(self):
        _odb_py.dbTechMinEncRule_swiginit(self, _odb_py.new_dbTechMinEncRule())
    __swig_destroy__ = _odb_py.delete_dbTechMinEncRule

# Register dbTechMinEncRule in _odb_py:
_odb_py.dbTechMinEncRule_swigregister(dbTechMinEncRule)

def dbTechMinEncRule_create(inly):
    return _odb_py.dbTechMinEncRule_create(inly)

def dbTechMinEncRule_getMinEncRule(inly, dbid):
    return _odb_py.dbTechMinEncRule_getMinEncRule(inly, dbid)

class dbTechV55InfluenceEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setV55InfluenceEntry(self, width, within, spacing):
        return _odb_py.dbTechV55InfluenceEntry_setV55InfluenceEntry(self, width, within, spacing)

    def writeLef(self, writer):
        return _odb_py.dbTechV55InfluenceEntry_writeLef(self, writer)

    @staticmethod
    def create(inly):
        return _odb_py.dbTechV55InfluenceEntry_create(inly)

    @staticmethod
    def getV55InfluenceEntry(*args):
        return _odb_py.dbTechV55InfluenceEntry_getV55InfluenceEntry(*args)

    def __init__(self):
        _odb_py.dbTechV55InfluenceEntry_swiginit(self, _odb_py.new_dbTechV55InfluenceEntry())
    __swig_destroy__ = _odb_py.delete_dbTechV55InfluenceEntry

# Register dbTechV55InfluenceEntry in _odb_py:
_odb_py.dbTechV55InfluenceEntry_swigregister(dbTechV55InfluenceEntry)

def dbTechV55InfluenceEntry_create(inly):
    return _odb_py.dbTechV55InfluenceEntry_create(inly)

def dbTechV55InfluenceEntry_getV55InfluenceEntry(*args):
    return _odb_py.dbTechV55InfluenceEntry_getV55InfluenceEntry(*args)

class dbTechLayerAntennaRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def isValid(self):
        return _odb_py.dbTechLayerAntennaRule_isValid(self)

    def writeLef(self, writer):
        return _odb_py.dbTechLayerAntennaRule_writeLef(self, writer)

    def setGatePlusDiffFactor(self, factor):
        return _odb_py.dbTechLayerAntennaRule_setGatePlusDiffFactor(self, factor)

    def setAreaMinusDiffFactor(self, factor):
        return _odb_py.dbTechLayerAntennaRule_setAreaMinusDiffFactor(self, factor)

    def setAreaFactor(self, factor, diffuse=False):
        return _odb_py.dbTechLayerAntennaRule_setAreaFactor(self, factor, diffuse)

    def setSideAreaFactor(self, factor, diffuse=False):
        return _odb_py.dbTechLayerAntennaRule_setSideAreaFactor(self, factor, diffuse)

    def hasAreaFactor(self):
        return _odb_py.dbTechLayerAntennaRule_hasAreaFactor(self)

    def hasSideAreaFactor(self):
        return _odb_py.dbTechLayerAntennaRule_hasSideAreaFactor(self)

    def getAreaFactor(self):
        return _odb_py.dbTechLayerAntennaRule_getAreaFactor(self)

    def getSideAreaFactor(self):
        return _odb_py.dbTechLayerAntennaRule_getSideAreaFactor(self)

    def isAreaFactorDiffUseOnly(self):
        return _odb_py.dbTechLayerAntennaRule_isAreaFactorDiffUseOnly(self)

    def isSideAreaFactorDiffUseOnly(self):
        return _odb_py.dbTechLayerAntennaRule_isSideAreaFactorDiffUseOnly(self)

    def hasAntennaCumRoutingPlusCut(self):
        return _odb_py.dbTechLayerAntennaRule_hasAntennaCumRoutingPlusCut(self)

    def setAntennaCumRoutingPlusCut(self, value=True):
        return _odb_py.dbTechLayerAntennaRule_setAntennaCumRoutingPlusCut(self, value)

    def getPAR(self):
        return _odb_py.dbTechLayerAntennaRule_getPAR(self)

    def getCAR(self):
        return _odb_py.dbTechLayerAntennaRule_getCAR(self)

    def getPSR(self):
        return _odb_py.dbTechLayerAntennaRule_getPSR(self)

    def getCSR(self):
        return _odb_py.dbTechLayerAntennaRule_getCSR(self)

    def getGatePlusDiffFactor(self):
        return _odb_py.dbTechLayerAntennaRule_getGatePlusDiffFactor(self)

    def getAreaMinusDiffFactor(self):
        return _odb_py.dbTechLayerAntennaRule_getAreaMinusDiffFactor(self)

    def setPAR(self, ratio):
        return _odb_py.dbTechLayerAntennaRule_setPAR(self, ratio)

    def setCAR(self, ratio):
        return _odb_py.dbTechLayerAntennaRule_setCAR(self, ratio)

    def setPSR(self, ratio):
        return _odb_py.dbTechLayerAntennaRule_setPSR(self, ratio)

    def setCSR(self, ratio):
        return _odb_py.dbTechLayerAntennaRule_setCSR(self, ratio)

    def setDiffPAR(self, *args):
        return _odb_py.dbTechLayerAntennaRule_setDiffPAR(self, *args)

    def setDiffCAR(self, *args):
        return _odb_py.dbTechLayerAntennaRule_setDiffCAR(self, *args)

    def setDiffPSR(self, *args):
        return _odb_py.dbTechLayerAntennaRule_setDiffPSR(self, *args)

    def setDiffCSR(self, *args):
        return _odb_py.dbTechLayerAntennaRule_setDiffCSR(self, *args)

    def setAreaDiffReduce(self, areas, factors):
        return _odb_py.dbTechLayerAntennaRule_setAreaDiffReduce(self, areas, factors)

    @staticmethod
    def getAntennaRule(inly, dbid):
        return _odb_py.dbTechLayerAntennaRule_getAntennaRule(inly, dbid)

    def __init__(self):
        _odb_py.dbTechLayerAntennaRule_swiginit(self, _odb_py.new_dbTechLayerAntennaRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerAntennaRule

# Register dbTechLayerAntennaRule in _odb_py:
_odb_py.dbTechLayerAntennaRule_swigregister(dbTechLayerAntennaRule)

def dbTechLayerAntennaRule_getAntennaRule(inly, dbid):
    return _odb_py.dbTechLayerAntennaRule_getAntennaRule(inly, dbid)

class dbTechAntennaPinModel(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def addGateAreaEntry(self, inval, refly=None):
        return _odb_py.dbTechAntennaPinModel_addGateAreaEntry(self, inval, refly)

    def addMaxAreaCAREntry(self, inval, refly=None):
        return _odb_py.dbTechAntennaPinModel_addMaxAreaCAREntry(self, inval, refly)

    def addMaxSideAreaCAREntry(self, inval, refly=None):
        return _odb_py.dbTechAntennaPinModel_addMaxSideAreaCAREntry(self, inval, refly)

    def addMaxCutCAREntry(self, inval, refly=None):
        return _odb_py.dbTechAntennaPinModel_addMaxCutCAREntry(self, inval, refly)

    def getGateArea(self):
        return _odb_py.dbTechAntennaPinModel_getGateArea(self)

    def getMaxAreaCAR(self):
        return _odb_py.dbTechAntennaPinModel_getMaxAreaCAR(self)

    def getMaxSideAreaCAR(self):
        return _odb_py.dbTechAntennaPinModel_getMaxSideAreaCAR(self)

    def getMaxCutCAR(self):
        return _odb_py.dbTechAntennaPinModel_getMaxCutCAR(self)

    def writeLef(self, tech, writer):
        return _odb_py.dbTechAntennaPinModel_writeLef(self, tech, writer)

    @staticmethod
    def getAntennaPinModel(master, dbid):
        return _odb_py.dbTechAntennaPinModel_getAntennaPinModel(master, dbid)

    def __init__(self):
        _odb_py.dbTechAntennaPinModel_swiginit(self, _odb_py.new_dbTechAntennaPinModel())
    __swig_destroy__ = _odb_py.delete_dbTechAntennaPinModel

# Register dbTechAntennaPinModel in _odb_py:
_odb_py.dbTechAntennaPinModel_swigregister(dbTechAntennaPinModel)

def dbTechAntennaPinModel_getAntennaPinModel(master, dbid):
    return _odb_py.dbTechAntennaPinModel_getAntennaPinModel(master, dbid)

class dbTechNonDefaultRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbTechNonDefaultRule_getName(self)

    def getConstName(self):
        return _odb_py.dbTechNonDefaultRule_getConstName(self)

    def isBlockRule(self):
        return _odb_py.dbTechNonDefaultRule_isBlockRule(self)

    def getLayerRule(self, layer):
        return _odb_py.dbTechNonDefaultRule_getLayerRule(self, layer)

    def getLayerRules(self, layer_rules):
        return _odb_py.dbTechNonDefaultRule_getLayerRules(self, layer_rules)

    def getVias(self, vias):
        return _odb_py.dbTechNonDefaultRule_getVias(self, vias)

    def findSameNetRule(self, l1, l2):
        return _odb_py.dbTechNonDefaultRule_findSameNetRule(self, l1, l2)

    def getSameNetRules(self, rules):
        return _odb_py.dbTechNonDefaultRule_getSameNetRules(self, rules)

    def getHardSpacing(self):
        return _odb_py.dbTechNonDefaultRule_getHardSpacing(self)

    def setHardSpacing(self, value):
        return _odb_py.dbTechNonDefaultRule_setHardSpacing(self, value)

    def addUseVia(self, via):
        return _odb_py.dbTechNonDefaultRule_addUseVia(self, via)

    def getUseVias(self, vias):
        return _odb_py.dbTechNonDefaultRule_getUseVias(self, vias)

    def addUseViaRule(self, rule):
        return _odb_py.dbTechNonDefaultRule_addUseViaRule(self, rule)

    def getUseViaRules(self, rules):
        return _odb_py.dbTechNonDefaultRule_getUseViaRules(self, rules)

    def setMinCuts(self, cut_layer, count):
        return _odb_py.dbTechNonDefaultRule_setMinCuts(self, cut_layer, count)

    def getMinCuts(self, cut_layer, count):
        return _odb_py.dbTechNonDefaultRule_getMinCuts(self, cut_layer, count)

    @staticmethod
    def create(*args):
        return _odb_py.dbTechNonDefaultRule_create(*args)

    @staticmethod
    def getTechNonDefaultRule(*args):
        return _odb_py.dbTechNonDefaultRule_getTechNonDefaultRule(*args)

    def __init__(self):
        _odb_py.dbTechNonDefaultRule_swiginit(self, _odb_py.new_dbTechNonDefaultRule())
    __swig_destroy__ = _odb_py.delete_dbTechNonDefaultRule

# Register dbTechNonDefaultRule in _odb_py:
_odb_py.dbTechNonDefaultRule_swigregister(dbTechNonDefaultRule)

def dbTechNonDefaultRule_create(*args):
    return _odb_py.dbTechNonDefaultRule_create(*args)

def dbTechNonDefaultRule_getTechNonDefaultRule(*args):
    return _odb_py.dbTechNonDefaultRule_getTechNonDefaultRule(*args)

class dbTechLayerRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getLayer(self):
        return _odb_py.dbTechLayerRule_getLayer(self)

    def isBlockRule(self):
        return _odb_py.dbTechLayerRule_isBlockRule(self)

    def getNonDefaultRule(self):
        return _odb_py.dbTechLayerRule_getNonDefaultRule(self)

    def getWidth(self):
        return _odb_py.dbTechLayerRule_getWidth(self)

    def setWidth(self, width):
        return _odb_py.dbTechLayerRule_setWidth(self, width)

    def getSpacing(self):
        return _odb_py.dbTechLayerRule_getSpacing(self)

    def setSpacing(self, spacing):
        return _odb_py.dbTechLayerRule_setSpacing(self, spacing)

    def getResistance(self):
        return _odb_py.dbTechLayerRule_getResistance(self)

    def setResistance(self, res):
        return _odb_py.dbTechLayerRule_setResistance(self, res)

    def getCapacitance(self):
        return _odb_py.dbTechLayerRule_getCapacitance(self)

    def setCapacitance(self, cap):
        return _odb_py.dbTechLayerRule_setCapacitance(self, cap)

    def getEdgeCapacitance(self):
        return _odb_py.dbTechLayerRule_getEdgeCapacitance(self)

    def setEdgeCapacitance(self, cap):
        return _odb_py.dbTechLayerRule_setEdgeCapacitance(self, cap)

    def getWireExtension(self):
        return _odb_py.dbTechLayerRule_getWireExtension(self)

    def setWireExtension(self, ext):
        return _odb_py.dbTechLayerRule_setWireExtension(self, ext)

    @staticmethod
    def create(rule, layer):
        return _odb_py.dbTechLayerRule_create(rule, layer)

    @staticmethod
    def getTechLayerRule(*args):
        return _odb_py.dbTechLayerRule_getTechLayerRule(*args)

    def __init__(self):
        _odb_py.dbTechLayerRule_swiginit(self, _odb_py.new_dbTechLayerRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerRule

# Register dbTechLayerRule in _odb_py:
_odb_py.dbTechLayerRule_swigregister(dbTechLayerRule)

def dbTechLayerRule_create(rule, layer):
    return _odb_py.dbTechLayerRule_create(rule, layer)

def dbTechLayerRule_getTechLayerRule(*args):
    return _odb_py.dbTechLayerRule_getTechLayerRule(*args)

class dbTechSameNetRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getLayer1(self):
        return _odb_py.dbTechSameNetRule_getLayer1(self)

    def getLayer2(self):
        return _odb_py.dbTechSameNetRule_getLayer2(self)

    def getSpacing(self):
        return _odb_py.dbTechSameNetRule_getSpacing(self)

    def setSpacing(self, spacing):
        return _odb_py.dbTechSameNetRule_setSpacing(self, spacing)

    def setAllowStackedVias(self, value):
        return _odb_py.dbTechSameNetRule_setAllowStackedVias(self, value)

    def getAllowStackedVias(self):
        return _odb_py.dbTechSameNetRule_getAllowStackedVias(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbTechSameNetRule_create(*args)

    @staticmethod
    def getTechSameNetRule(tech, oid):
        return _odb_py.dbTechSameNetRule_getTechSameNetRule(tech, oid)

    def __init__(self):
        _odb_py.dbTechSameNetRule_swiginit(self, _odb_py.new_dbTechSameNetRule())
    __swig_destroy__ = _odb_py.delete_dbTechSameNetRule

# Register dbTechSameNetRule in _odb_py:
_odb_py.dbTechSameNetRule_swigregister(dbTechSameNetRule)

def dbTechSameNetRule_create(*args):
    return _odb_py.dbTechSameNetRule_create(*args)

def dbTechSameNetRule_getTechSameNetRule(tech, oid):
    return _odb_py.dbTechSameNetRule_getTechSameNetRule(tech, oid)

class dbViaParams(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _odb_py.dbViaParams_swiginit(self, _odb_py.new_dbViaParams(*args))
    __swig_destroy__ = _odb_py.delete_dbViaParams

    def getXCutSize(self):
        return _odb_py.dbViaParams_getXCutSize(self)

    def getYCutSize(self):
        return _odb_py.dbViaParams_getYCutSize(self)

    def getXCutSpacing(self):
        return _odb_py.dbViaParams_getXCutSpacing(self)

    def getYCutSpacing(self):
        return _odb_py.dbViaParams_getYCutSpacing(self)

    def getXTopEnclosure(self):
        return _odb_py.dbViaParams_getXTopEnclosure(self)

    def getYTopEnclosure(self):
        return _odb_py.dbViaParams_getYTopEnclosure(self)

    def getXBottomEnclosure(self):
        return _odb_py.dbViaParams_getXBottomEnclosure(self)

    def getYBottomEnclosure(self):
        return _odb_py.dbViaParams_getYBottomEnclosure(self)

    def getNumCutRows(self):
        return _odb_py.dbViaParams_getNumCutRows(self)

    def getNumCutCols(self):
        return _odb_py.dbViaParams_getNumCutCols(self)

    def getXOrigin(self):
        return _odb_py.dbViaParams_getXOrigin(self)

    def getYOrigin(self):
        return _odb_py.dbViaParams_getYOrigin(self)

    def getXTopOffset(self):
        return _odb_py.dbViaParams_getXTopOffset(self)

    def getYTopOffset(self):
        return _odb_py.dbViaParams_getYTopOffset(self)

    def getXBottomOffset(self):
        return _odb_py.dbViaParams_getXBottomOffset(self)

    def getYBottomOffset(self):
        return _odb_py.dbViaParams_getYBottomOffset(self)

    def getTopLayer(self):
        return _odb_py.dbViaParams_getTopLayer(self)

    def getCutLayer(self):
        return _odb_py.dbViaParams_getCutLayer(self)

    def getBottomLayer(self):
        return _odb_py.dbViaParams_getBottomLayer(self)

    def setXCutSize(self, value):
        return _odb_py.dbViaParams_setXCutSize(self, value)

    def setYCutSize(self, value):
        return _odb_py.dbViaParams_setYCutSize(self, value)

    def setXCutSpacing(self, value):
        return _odb_py.dbViaParams_setXCutSpacing(self, value)

    def setYCutSpacing(self, value):
        return _odb_py.dbViaParams_setYCutSpacing(self, value)

    def setXTopEnclosure(self, value):
        return _odb_py.dbViaParams_setXTopEnclosure(self, value)

    def setYTopEnclosure(self, value):
        return _odb_py.dbViaParams_setYTopEnclosure(self, value)

    def setXBottomEnclosure(self, value):
        return _odb_py.dbViaParams_setXBottomEnclosure(self, value)

    def setYBottomEnclosure(self, value):
        return _odb_py.dbViaParams_setYBottomEnclosure(self, value)

    def setNumCutRows(self, value):
        return _odb_py.dbViaParams_setNumCutRows(self, value)

    def setNumCutCols(self, value):
        return _odb_py.dbViaParams_setNumCutCols(self, value)

    def setXOrigin(self, value):
        return _odb_py.dbViaParams_setXOrigin(self, value)

    def setYOrigin(self, value):
        return _odb_py.dbViaParams_setYOrigin(self, value)

    def setXTopOffset(self, value):
        return _odb_py.dbViaParams_setXTopOffset(self, value)

    def setYTopOffset(self, value):
        return _odb_py.dbViaParams_setYTopOffset(self, value)

    def setXBottomOffset(self, value):
        return _odb_py.dbViaParams_setXBottomOffset(self, value)

    def setYBottomOffset(self, value):
        return _odb_py.dbViaParams_setYBottomOffset(self, value)

    def setTopLayer(self, layer):
        return _odb_py.dbViaParams_setTopLayer(self, layer)

    def setCutLayer(self, layer):
        return _odb_py.dbViaParams_setCutLayer(self, layer)

    def setBottomLayer(self, layer):
        return _odb_py.dbViaParams_setBottomLayer(self, layer)

# Register dbViaParams in _odb_py:
_odb_py.dbViaParams_swigregister(dbViaParams)

class dbAccessPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setPoint(self, point):
        return _odb_py.dbAccessPoint_setPoint(self, point)

    def getPoint(self):
        return _odb_py.dbAccessPoint_getPoint(self)

    def setLayer(self, layer):
        return _odb_py.dbAccessPoint_setLayer(self, layer)

    def setAccesses(self, accesses):
        return _odb_py.dbAccessPoint_setAccesses(self, accesses)

    def getAccesses(self, tbl):
        return _odb_py.dbAccessPoint_getAccesses(self, tbl)

    def setLowType(self, type_low):
        return _odb_py.dbAccessPoint_setLowType(self, type_low)

    def getLowType(self):
        return _odb_py.dbAccessPoint_getLowType(self)

    def setHighType(self, type_high):
        return _odb_py.dbAccessPoint_setHighType(self, type_high)

    def getHighType(self):
        return _odb_py.dbAccessPoint_getHighType(self)

    def setAccess(self, access, dir):
        return _odb_py.dbAccessPoint_setAccess(self, access, dir)

    def hasAccess(self, *args):
        return _odb_py.dbAccessPoint_hasAccess(self, *args)

    def getLayer(self):
        return _odb_py.dbAccessPoint_getLayer(self)

    def getMPin(self):
        return _odb_py.dbAccessPoint_getMPin(self)

    def getBPin(self):
        return _odb_py.dbAccessPoint_getBPin(self)

    def getVias(self):
        return _odb_py.dbAccessPoint_getVias(self)

    def addTechVia(self, num_cuts, via):
        return _odb_py.dbAccessPoint_addTechVia(self, num_cuts, via)

    def addBlockVia(self, num_cuts, via):
        return _odb_py.dbAccessPoint_addBlockVia(self, num_cuts, via)

    def addSegment(self, segment, begin_style_trunc, end_style_trunc):
        return _odb_py.dbAccessPoint_addSegment(self, segment, begin_style_trunc, end_style_trunc)

    def getSegments(self):
        return _odb_py.dbAccessPoint_getSegments(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbAccessPoint_create(*args)

    @staticmethod
    def getAccessPoint(block, dbid):
        return _odb_py.dbAccessPoint_getAccessPoint(block, dbid)

    @staticmethod
    def destroy(ap):
        return _odb_py.dbAccessPoint_destroy(ap)

    def __init__(self):
        _odb_py.dbAccessPoint_swiginit(self, _odb_py.new_dbAccessPoint())
    __swig_destroy__ = _odb_py.delete_dbAccessPoint

# Register dbAccessPoint in _odb_py:
_odb_py.dbAccessPoint_swigregister(dbAccessPoint)

def dbAccessPoint_create(*args):
    return _odb_py.dbAccessPoint_create(*args)

def dbAccessPoint_getAccessPoint(block, dbid):
    return _odb_py.dbAccessPoint_getAccessPoint(block, dbid)

def dbAccessPoint_destroy(ap):
    return _odb_py.dbAccessPoint_destroy(ap)

class dbDft(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setScanInserted(self, scan_inserted):
        return _odb_py.dbDft_setScanInserted(self, scan_inserted)

    def isScanInserted(self):
        return _odb_py.dbDft_isScanInserted(self)

    def getScanChains(self):
        return _odb_py.dbDft_getScanChains(self)

    def __init__(self):
        _odb_py.dbDft_swiginit(self, _odb_py.new_dbDft())
    __swig_destroy__ = _odb_py.delete_dbDft

# Register dbDft in _odb_py:
_odb_py.dbDft_swigregister(dbDft)

class dbGCellGrid(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getGridX(self):
        return _odb_py.dbGCellGrid_getGridX(self)

    def getGridY(self):
        return _odb_py.dbGCellGrid_getGridY(self)

    def getBlock(self):
        return _odb_py.dbGCellGrid_getBlock(self)

    def addGridPatternX(self, origin_x, line_count, step):
        return _odb_py.dbGCellGrid_addGridPatternX(self, origin_x, line_count, step)

    def addGridPatternY(self, origin_y, line_count, step):
        return _odb_py.dbGCellGrid_addGridPatternY(self, origin_y, line_count, step)

    def getNumGridPatternsX(self):
        return _odb_py.dbGCellGrid_getNumGridPatternsX(self)

    def getNumGridPatternsY(self):
        return _odb_py.dbGCellGrid_getNumGridPatternsY(self)

    def getGridPatternX(self, i):
        return _odb_py.dbGCellGrid_getGridPatternX(self, i)

    def getGridPatternY(self, i):
        return _odb_py.dbGCellGrid_getGridPatternY(self, i)

    @staticmethod
    def create(block):
        return _odb_py.dbGCellGrid_create(block)

    @staticmethod
    def getGCellGrid(block, oid):
        return _odb_py.dbGCellGrid_getGCellGrid(block, oid)

    def getXIdx(self, x):
        return _odb_py.dbGCellGrid_getXIdx(self, x)

    def getYIdx(self, y):
        return _odb_py.dbGCellGrid_getYIdx(self, y)

    def getCapacity(self, layer, x_idx, y_idx):
        return _odb_py.dbGCellGrid_getCapacity(self, layer, x_idx, y_idx)

    def getUsage(self, layer, x_idx, y_idx):
        return _odb_py.dbGCellGrid_getUsage(self, layer, x_idx, y_idx)

    def setCapacity(self, layer, x_idx, y_idx, capacity):
        return _odb_py.dbGCellGrid_setCapacity(self, layer, x_idx, y_idx, capacity)

    def setUsage(self, layer, x_idx, y_idx, use):
        return _odb_py.dbGCellGrid_setUsage(self, layer, x_idx, y_idx, use)

    def resetCongestionMap(self):
        return _odb_py.dbGCellGrid_resetCongestionMap(self)

    def resetGrid(self):
        return _odb_py.dbGCellGrid_resetGrid(self)

    def getLayerCongestionMap(self, layer):
        return _odb_py.dbGCellGrid_getLayerCongestionMap(self, layer)

    def getDirectionCongestionMap(self, direction):
        return _odb_py.dbGCellGrid_getDirectionCongestionMap(self, direction)

    def __init__(self):
        _odb_py.dbGCellGrid_swiginit(self, _odb_py.new_dbGCellGrid())
    __swig_destroy__ = _odb_py.delete_dbGCellGrid

# Register dbGCellGrid in _odb_py:
_odb_py.dbGCellGrid_swigregister(dbGCellGrid)

def dbGCellGrid_create(block):
    return _odb_py.dbGCellGrid_create(block)

def dbGCellGrid_getGCellGrid(block, oid):
    return _odb_py.dbGCellGrid_getGCellGrid(block, oid)

class dbGlobalConnect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getRegion(self):
        return _odb_py.dbGlobalConnect_getRegion(self)

    def getNet(self):
        return _odb_py.dbGlobalConnect_getNet(self)

    def getInstPattern(self):
        return _odb_py.dbGlobalConnect_getInstPattern(self)

    def getPinPattern(self):
        return _odb_py.dbGlobalConnect_getPinPattern(self)

    def getInsts(self):
        return _odb_py.dbGlobalConnect_getInsts(self)

    def connect(self, inst):
        return _odb_py.dbGlobalConnect_connect(self, inst)

    @staticmethod
    def create(net, region, inst_pattern, pin_pattern):
        return _odb_py.dbGlobalConnect_create(net, region, inst_pattern, pin_pattern)

    @staticmethod
    def destroy(global_connect):
        return _odb_py.dbGlobalConnect_destroy(global_connect)

    def __init__(self):
        _odb_py.dbGlobalConnect_swiginit(self, _odb_py.new_dbGlobalConnect())
    __swig_destroy__ = _odb_py.delete_dbGlobalConnect

# Register dbGlobalConnect in _odb_py:
_odb_py.dbGlobalConnect_swigregister(dbGlobalConnect)

def dbGlobalConnect_create(net, region, inst_pattern, pin_pattern):
    return _odb_py.dbGlobalConnect_create(net, region, inst_pattern, pin_pattern)

def dbGlobalConnect_destroy(global_connect):
    return _odb_py.dbGlobalConnect_destroy(global_connect)

class dbGroup(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbGroup_getName(self)

    def getParentGroup(self):
        return _odb_py.dbGroup_getParentGroup(self)

    def getRegion(self):
        return _odb_py.dbGroup_getRegion(self)

    def setType(self, type):
        return _odb_py.dbGroup_setType(self, type)

    def getType(self):
        return _odb_py.dbGroup_getType(self)

    def addModInst(self, modinst):
        return _odb_py.dbGroup_addModInst(self, modinst)

    def removeModInst(self, modinst):
        return _odb_py.dbGroup_removeModInst(self, modinst)

    def getModInsts(self):
        return _odb_py.dbGroup_getModInsts(self)

    def addInst(self, inst):
        return _odb_py.dbGroup_addInst(self, inst)

    def removeInst(self, inst):
        return _odb_py.dbGroup_removeInst(self, inst)

    def getInsts(self):
        return _odb_py.dbGroup_getInsts(self)

    def addGroup(self, group):
        return _odb_py.dbGroup_addGroup(self, group)

    def removeGroup(self, group):
        return _odb_py.dbGroup_removeGroup(self, group)

    def getGroups(self):
        return _odb_py.dbGroup_getGroups(self)

    def addPowerNet(self, net):
        return _odb_py.dbGroup_addPowerNet(self, net)

    def addGroundNet(self, net):
        return _odb_py.dbGroup_addGroundNet(self, net)

    def removeNet(self, net):
        return _odb_py.dbGroup_removeNet(self, net)

    def getPowerNets(self):
        return _odb_py.dbGroup_getPowerNets(self)

    def getGroundNets(self):
        return _odb_py.dbGroup_getGroundNets(self)

    @staticmethod
    def create(*args):
        return _odb_py.dbGroup_create(*args)

    @staticmethod
    def destroy(group):
        return _odb_py.dbGroup_destroy(group)

    @staticmethod
    def getGroup(block_, dbid_):
        return _odb_py.dbGroup_getGroup(block_, dbid_)

    def __init__(self):
        _odb_py.dbGroup_swiginit(self, _odb_py.new_dbGroup())
    __swig_destroy__ = _odb_py.delete_dbGroup

# Register dbGroup in _odb_py:
_odb_py.dbGroup_swigregister(dbGroup)

def dbGroup_create(*args):
    return _odb_py.dbGroup_create(*args)

def dbGroup_destroy(group):
    return _odb_py.dbGroup_destroy(group)

def dbGroup_getGroup(block_, dbid_):
    return _odb_py.dbGroup_getGroup(block_, dbid_)

class dbGuide(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBox(self):
        return _odb_py.dbGuide_getBox(self)

    def getNet(self):
        return _odb_py.dbGuide_getNet(self)

    def getLayer(self):
        return _odb_py.dbGuide_getLayer(self)

    @staticmethod
    def create(net, layer, box):
        return _odb_py.dbGuide_create(net, layer, box)

    @staticmethod
    def getGuide(block, dbid):
        return _odb_py.dbGuide_getGuide(block, dbid)

    @staticmethod
    def destroy(guide):
        return _odb_py.dbGuide_destroy(guide)

    def __init__(self):
        _odb_py.dbGuide_swiginit(self, _odb_py.new_dbGuide())
    __swig_destroy__ = _odb_py.delete_dbGuide

# Register dbGuide in _odb_py:
_odb_py.dbGuide_swigregister(dbGuide)

def dbGuide_create(net, layer, box):
    return _odb_py.dbGuide_create(net, layer, box)

def dbGuide_getGuide(block, dbid):
    return _odb_py.dbGuide_getGuide(block, dbid)

def dbGuide_destroy(guide):
    return _odb_py.dbGuide_destroy(guide)

class dbIsolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbIsolation_getName(self)

    def getAppliesTo(self):
        return _odb_py.dbIsolation_getAppliesTo(self)

    def getClampValue(self):
        return _odb_py.dbIsolation_getClampValue(self)

    def getIsolationSignal(self):
        return _odb_py.dbIsolation_getIsolationSignal(self)

    def getIsolationSense(self):
        return _odb_py.dbIsolation_getIsolationSense(self)

    def getLocation(self):
        return _odb_py.dbIsolation_getLocation(self)

    def setPowerDomain(self, power_domain):
        return _odb_py.dbIsolation_setPowerDomain(self, power_domain)

    def getPowerDomain(self):
        return _odb_py.dbIsolation_getPowerDomain(self)

    @staticmethod
    def create(block, name):
        return _odb_py.dbIsolation_create(block, name)

    @staticmethod
    def destroy(iso):
        return _odb_py.dbIsolation_destroy(iso)

    def setAppliesTo(self, applies_to):
        return _odb_py.dbIsolation_setAppliesTo(self, applies_to)

    def setClampValue(self, clamp_value):
        return _odb_py.dbIsolation_setClampValue(self, clamp_value)

    def setIsolationSignal(self, isolation_signal):
        return _odb_py.dbIsolation_setIsolationSignal(self, isolation_signal)

    def setIsolationSense(self, isolation_sense):
        return _odb_py.dbIsolation_setIsolationSense(self, isolation_sense)

    def setLocation(self, location):
        return _odb_py.dbIsolation_setLocation(self, location)

    def addIsolationCell(self, master):
        return _odb_py.dbIsolation_addIsolationCell(self, master)

    def getIsolationCells(self):
        return _odb_py.dbIsolation_getIsolationCells(self)

    def __init__(self):
        _odb_py.dbIsolation_swiginit(self, _odb_py.new_dbIsolation())
    __swig_destroy__ = _odb_py.delete_dbIsolation

# Register dbIsolation in _odb_py:
_odb_py.dbIsolation_swigregister(dbIsolation)

def dbIsolation_create(block, name):
    return _odb_py.dbIsolation_create(block, name)

def dbIsolation_destroy(iso):
    return _odb_py.dbIsolation_destroy(iso)

class dbLevelShifter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbLevelShifter_getName(self)

    def getDomain(self):
        return _odb_py.dbLevelShifter_getDomain(self)

    def setSource(self, source):
        return _odb_py.dbLevelShifter_setSource(self, source)

    def getSource(self):
        return _odb_py.dbLevelShifter_getSource(self)

    def setSink(self, sink):
        return _odb_py.dbLevelShifter_setSink(self, sink)

    def getSink(self):
        return _odb_py.dbLevelShifter_getSink(self)

    def setUseFunctionalEquivalence(self, use_functional_equivalence):
        return _odb_py.dbLevelShifter_setUseFunctionalEquivalence(self, use_functional_equivalence)

    def isUseFunctionalEquivalence(self):
        return _odb_py.dbLevelShifter_isUseFunctionalEquivalence(self)

    def setAppliesTo(self, applies_to):
        return _odb_py.dbLevelShifter_setAppliesTo(self, applies_to)

    def getAppliesTo(self):
        return _odb_py.dbLevelShifter_getAppliesTo(self)

    def setAppliesToBoundary(self, applies_to_boundary):
        return _odb_py.dbLevelShifter_setAppliesToBoundary(self, applies_to_boundary)

    def getAppliesToBoundary(self):
        return _odb_py.dbLevelShifter_getAppliesToBoundary(self)

    def setRule(self, rule):
        return _odb_py.dbLevelShifter_setRule(self, rule)

    def getRule(self):
        return _odb_py.dbLevelShifter_getRule(self)

    def setThreshold(self, threshold):
        return _odb_py.dbLevelShifter_setThreshold(self, threshold)

    def getThreshold(self):
        return _odb_py.dbLevelShifter_getThreshold(self)

    def setNoShift(self, no_shift):
        return _odb_py.dbLevelShifter_setNoShift(self, no_shift)

    def isNoShift(self):
        return _odb_py.dbLevelShifter_isNoShift(self)

    def setForceShift(self, force_shift):
        return _odb_py.dbLevelShifter_setForceShift(self, force_shift)

    def isForceShift(self):
        return _odb_py.dbLevelShifter_isForceShift(self)

    def setLocation(self, location):
        return _odb_py.dbLevelShifter_setLocation(self, location)

    def getLocation(self):
        return _odb_py.dbLevelShifter_getLocation(self)

    def setInputSupply(self, input_supply):
        return _odb_py.dbLevelShifter_setInputSupply(self, input_supply)

    def getInputSupply(self):
        return _odb_py.dbLevelShifter_getInputSupply(self)

    def setOutputSupply(self, output_supply):
        return _odb_py.dbLevelShifter_setOutputSupply(self, output_supply)

    def getOutputSupply(self):
        return _odb_py.dbLevelShifter_getOutputSupply(self)

    def setInternalSupply(self, internal_supply):
        return _odb_py.dbLevelShifter_setInternalSupply(self, internal_supply)

    def getInternalSupply(self):
        return _odb_py.dbLevelShifter_getInternalSupply(self)

    def setNamePrefix(self, name_prefix):
        return _odb_py.dbLevelShifter_setNamePrefix(self, name_prefix)

    def getNamePrefix(self):
        return _odb_py.dbLevelShifter_getNamePrefix(self)

    def setNameSuffix(self, name_suffix):
        return _odb_py.dbLevelShifter_setNameSuffix(self, name_suffix)

    def getNameSuffix(self):
        return _odb_py.dbLevelShifter_getNameSuffix(self)

    def setCellName(self, cell_name):
        return _odb_py.dbLevelShifter_setCellName(self, cell_name)

    def getCellName(self):
        return _odb_py.dbLevelShifter_getCellName(self)

    def setCellInput(self, cell_input):
        return _odb_py.dbLevelShifter_setCellInput(self, cell_input)

    def getCellInput(self):
        return _odb_py.dbLevelShifter_getCellInput(self)

    def setCellOutput(self, cell_output):
        return _odb_py.dbLevelShifter_setCellOutput(self, cell_output)

    def getCellOutput(self):
        return _odb_py.dbLevelShifter_getCellOutput(self)

    @staticmethod
    def create(block, name, domain):
        return _odb_py.dbLevelShifter_create(block, name, domain)

    @staticmethod
    def destroy(shifter):
        return _odb_py.dbLevelShifter_destroy(shifter)

    def addElement(self, element):
        return _odb_py.dbLevelShifter_addElement(self, element)

    def addExcludeElement(self, element):
        return _odb_py.dbLevelShifter_addExcludeElement(self, element)

    def addInstance(self, instance, port):
        return _odb_py.dbLevelShifter_addInstance(self, instance, port)

    def getElements(self):
        return _odb_py.dbLevelShifter_getElements(self)

    def getExcludeElements(self):
        return _odb_py.dbLevelShifter_getExcludeElements(self)

    def getInstances(self):
        return _odb_py.dbLevelShifter_getInstances(self)

    def __init__(self):
        _odb_py.dbLevelShifter_swiginit(self, _odb_py.new_dbLevelShifter())
    __swig_destroy__ = _odb_py.delete_dbLevelShifter

# Register dbLevelShifter in _odb_py:
_odb_py.dbLevelShifter_swigregister(dbLevelShifter)

def dbLevelShifter_create(block, name, domain):
    return _odb_py.dbLevelShifter_create(block, name, domain)

def dbLevelShifter_destroy(shifter):
    return _odb_py.dbLevelShifter_destroy(shifter)

class dbLogicPort(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbLogicPort_getName(self)

    def getDirection(self):
        return _odb_py.dbLogicPort_getDirection(self)

    @staticmethod
    def create(block, name, direction):
        return _odb_py.dbLogicPort_create(block, name, direction)

    @staticmethod
    def destroy(lp):
        return _odb_py.dbLogicPort_destroy(lp)

    def __init__(self):
        _odb_py.dbLogicPort_swiginit(self, _odb_py.new_dbLogicPort())
    __swig_destroy__ = _odb_py.delete_dbLogicPort

# Register dbLogicPort in _odb_py:
_odb_py.dbLogicPort_swigregister(dbLogicPort)

def dbLogicPort_create(block, name, direction):
    return _odb_py.dbLogicPort_create(block, name, direction)

def dbLogicPort_destroy(lp):
    return _odb_py.dbLogicPort_destroy(lp)

class dbMetalWidthViaMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setViaCutClass(self, via_cut_class):
        return _odb_py.dbMetalWidthViaMap_setViaCutClass(self, via_cut_class)

    def isViaCutClass(self):
        return _odb_py.dbMetalWidthViaMap_isViaCutClass(self)

    def setCutLayer(self, cut_layer):
        return _odb_py.dbMetalWidthViaMap_setCutLayer(self, cut_layer)

    def setBelowLayerWidthLow(self, below_layer_width_low):
        return _odb_py.dbMetalWidthViaMap_setBelowLayerWidthLow(self, below_layer_width_low)

    def getBelowLayerWidthLow(self):
        return _odb_py.dbMetalWidthViaMap_getBelowLayerWidthLow(self)

    def setBelowLayerWidthHigh(self, below_layer_width_high):
        return _odb_py.dbMetalWidthViaMap_setBelowLayerWidthHigh(self, below_layer_width_high)

    def getBelowLayerWidthHigh(self):
        return _odb_py.dbMetalWidthViaMap_getBelowLayerWidthHigh(self)

    def setAboveLayerWidthLow(self, above_layer_width_low):
        return _odb_py.dbMetalWidthViaMap_setAboveLayerWidthLow(self, above_layer_width_low)

    def getAboveLayerWidthLow(self):
        return _odb_py.dbMetalWidthViaMap_getAboveLayerWidthLow(self)

    def setAboveLayerWidthHigh(self, above_layer_width_high):
        return _odb_py.dbMetalWidthViaMap_setAboveLayerWidthHigh(self, above_layer_width_high)

    def getAboveLayerWidthHigh(self):
        return _odb_py.dbMetalWidthViaMap_getAboveLayerWidthHigh(self)

    def setViaName(self, via_name):
        return _odb_py.dbMetalWidthViaMap_setViaName(self, via_name)

    def getViaName(self):
        return _odb_py.dbMetalWidthViaMap_getViaName(self)

    def setPgVia(self, pg_via):
        return _odb_py.dbMetalWidthViaMap_setPgVia(self, pg_via)

    def isPgVia(self):
        return _odb_py.dbMetalWidthViaMap_isPgVia(self)

    def getCutLayer(self):
        return _odb_py.dbMetalWidthViaMap_getCutLayer(self)

    @staticmethod
    def create(tech):
        return _odb_py.dbMetalWidthViaMap_create(tech)

    @staticmethod
    def destroy(via_map):
        return _odb_py.dbMetalWidthViaMap_destroy(via_map)

    @staticmethod
    def getMetalWidthViaMap(tech, dbid):
        return _odb_py.dbMetalWidthViaMap_getMetalWidthViaMap(tech, dbid)

    def __init__(self):
        _odb_py.dbMetalWidthViaMap_swiginit(self, _odb_py.new_dbMetalWidthViaMap())
    __swig_destroy__ = _odb_py.delete_dbMetalWidthViaMap

# Register dbMetalWidthViaMap in _odb_py:
_odb_py.dbMetalWidthViaMap_swigregister(dbMetalWidthViaMap)

def dbMetalWidthViaMap_create(tech):
    return _odb_py.dbMetalWidthViaMap_create(tech)

def dbMetalWidthViaMap_destroy(via_map):
    return _odb_py.dbMetalWidthViaMap_destroy(via_map)

def dbMetalWidthViaMap_getMetalWidthViaMap(tech, dbid):
    return _odb_py.dbMetalWidthViaMap_getMetalWidthViaMap(tech, dbid)

class dbModBTerm(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbModBTerm_getName(self)

    def getParent(self):
        return _odb_py.dbModBTerm_getParent(self)

    def setParentModITerm(self, parent_pin):
        return _odb_py.dbModBTerm_setParentModITerm(self, parent_pin)

    def getParentModITerm(self):
        return _odb_py.dbModBTerm_getParentModITerm(self)

    def setModNet(self, modNet):
        return _odb_py.dbModBTerm_setModNet(self, modNet)

    def getModNet(self):
        return _odb_py.dbModBTerm_getModNet(self)

    def setSigType(self, type):
        return _odb_py.dbModBTerm_setSigType(self, type)

    def getSigType(self):
        return _odb_py.dbModBTerm_getSigType(self)

    def setIoType(self, type):
        return _odb_py.dbModBTerm_setIoType(self, type)

    def getIoType(self):
        return _odb_py.dbModBTerm_getIoType(self)

    def connect(self, net):
        return _odb_py.dbModBTerm_connect(self, net)

    def disconnect(self):
        return _odb_py.dbModBTerm_disconnect(self)

    def staSetPort(self, p):
        return _odb_py.dbModBTerm_staSetPort(self, p)

    def staPort(self):
        return _odb_py.dbModBTerm_staPort(self)

    @staticmethod
    def create(parentModule, name):
        return _odb_py.dbModBTerm_create(parentModule, name)

    def __init__(self):
        _odb_py.dbModBTerm_swiginit(self, _odb_py.new_dbModBTerm())
    __swig_destroy__ = _odb_py.delete_dbModBTerm

# Register dbModBTerm in _odb_py:
_odb_py.dbModBTerm_swigregister(dbModBTerm)

def dbModBTerm_create(parentModule, name):
    return _odb_py.dbModBTerm_create(parentModule, name)

class dbModInst(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbModInst_getName(self)

    def getParent(self):
        return _odb_py.dbModInst_getParent(self)

    def getMaster(self):
        return _odb_py.dbModInst_getMaster(self)

    def getGroup(self):
        return _odb_py.dbModInst_getGroup(self)

    def getHierarchicalName(self):
        return _odb_py.dbModInst_getHierarchicalName(self)

    def findModITerm(self, name):
        return _odb_py.dbModInst_findModITerm(self, name)

    def getModITerms(self):
        return _odb_py.dbModInst_getModITerms(self)

    @staticmethod
    def create(parentModule, masterModule, name):
        return _odb_py.dbModInst_create(parentModule, masterModule, name)

    @staticmethod
    def destroy(*args):
        return _odb_py.dbModInst_destroy(*args)

    @staticmethod
    def getModInst(block_, dbid_):
        return _odb_py.dbModInst_getModInst(block_, dbid_)

    def __init__(self):
        _odb_py.dbModInst_swiginit(self, _odb_py.new_dbModInst())
    __swig_destroy__ = _odb_py.delete_dbModInst

# Register dbModInst in _odb_py:
_odb_py.dbModInst_swigregister(dbModInst)

def dbModInst_create(parentModule, masterModule, name):
    return _odb_py.dbModInst_create(parentModule, masterModule, name)

def dbModInst_destroy(*args):
    return _odb_py.dbModInst_destroy(*args)

def dbModInst_getModInst(block_, dbid_):
    return _odb_py.dbModInst_getModInst(block_, dbid_)

class dbModITerm(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbModITerm_getName(self)

    def getParent(self):
        return _odb_py.dbModITerm_getParent(self)

    def setModNet(self, modNet):
        return _odb_py.dbModITerm_setModNet(self, modNet)

    def getModNet(self):
        return _odb_py.dbModITerm_getModNet(self)

    def setChildModBTerm(self, child_port):
        return _odb_py.dbModITerm_setChildModBTerm(self, child_port)

    def getChildModBTerm(self):
        return _odb_py.dbModITerm_getChildModBTerm(self)

    def connect(self, modnet):
        return _odb_py.dbModITerm_connect(self, modnet)

    def disconnect(self):
        return _odb_py.dbModITerm_disconnect(self)

    @staticmethod
    def create(parentInstance, name):
        return _odb_py.dbModITerm_create(parentInstance, name)

    def __init__(self):
        _odb_py.dbModITerm_swiginit(self, _odb_py.new_dbModITerm())
    __swig_destroy__ = _odb_py.delete_dbModITerm

# Register dbModITerm in _odb_py:
_odb_py.dbModITerm_swigregister(dbModITerm)

def dbModITerm_create(parentInstance, name):
    return _odb_py.dbModITerm_create(parentInstance, name)

class dbModNet(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getParent(self):
        return _odb_py.dbModNet_getParent(self)

    def getModITerms(self):
        return _odb_py.dbModNet_getModITerms(self)

    def getModBTerms(self):
        return _odb_py.dbModNet_getModBTerms(self)

    def getITerms(self):
        return _odb_py.dbModNet_getITerms(self)

    def getBTerms(self):
        return _odb_py.dbModNet_getBTerms(self)

    def getName(self):
        return _odb_py.dbModNet_getName(self)

    @staticmethod
    def create(parentModule, name):
        return _odb_py.dbModNet_create(parentModule, name)

    def __init__(self):
        _odb_py.dbModNet_swiginit(self, _odb_py.new_dbModNet())
    __swig_destroy__ = _odb_py.delete_dbModNet

# Register dbModNet in _odb_py:
_odb_py.dbModNet_swigregister(dbModNet)

def dbModNet_create(parentModule, name):
    return _odb_py.dbModNet_create(parentModule, name)

class dbModule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbModule_getName(self)

    def setModInst(self, mod_inst):
        return _odb_py.dbModule_setModInst(self, mod_inst)

    def getModInst(self):
        return _odb_py.dbModule_getModInst(self)

    def getHierarchicalName(self):
        return _odb_py.dbModule_getHierarchicalName(self)

    def getModNet(self, net_name):
        return _odb_py.dbModule_getModNet(self, net_name)

    def addInst(self, inst):
        return _odb_py.dbModule_addInst(self, inst)

    def getOwner(self):
        return _odb_py.dbModule_getOwner(self)

    def getChildren(self):
        return _odb_py.dbModule_getChildren(self)

    def getModInsts(self):
        return _odb_py.dbModule_getModInsts(self)

    def getModNets(self):
        return _odb_py.dbModule_getModNets(self)

    def getModBTerms(self):
        return _odb_py.dbModule_getModBTerms(self)

    def getInsts(self):
        return _odb_py.dbModule_getInsts(self)

    def findModInst(self, name):
        return _odb_py.dbModule_findModInst(self, name)

    def findDbInst(self, name):
        return _odb_py.dbModule_findDbInst(self, name)

    def findModBTerm(self, name):
        return _odb_py.dbModule_findModBTerm(self, name)

    def getLeafInsts(self):
        return _odb_py.dbModule_getLeafInsts(self)

    def getModInstCount(self):
        return _odb_py.dbModule_getModInstCount(self)

    def getDbInstCount(self):
        return _odb_py.dbModule_getDbInstCount(self)

    def staSetCell(self, cell):
        return _odb_py.dbModule_staSetCell(self, cell)

    def getStaCell(self):
        return _odb_py.dbModule_getStaCell(self)

    @staticmethod
    def create(block, name):
        return _odb_py.dbModule_create(block, name)

    @staticmethod
    def destroy(module):
        return _odb_py.dbModule_destroy(module)

    @staticmethod
    def getModule(block_, dbid_):
        return _odb_py.dbModule_getModule(block_, dbid_)

    def __init__(self):
        _odb_py.dbModule_swiginit(self, _odb_py.new_dbModule())
    __swig_destroy__ = _odb_py.delete_dbModule

# Register dbModule in _odb_py:
_odb_py.dbModule_swigregister(dbModule)

def dbModule_create(block, name):
    return _odb_py.dbModule_create(block, name)

def dbModule_destroy(module):
    return _odb_py.dbModule_destroy(module)

def dbModule_getModule(block_, dbid_):
    return _odb_py.dbModule_getModule(block_, dbid_)

class dbNetTrack(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getBox(self):
        return _odb_py.dbNetTrack_getBox(self)

    def getNet(self):
        return _odb_py.dbNetTrack_getNet(self)

    def getLayer(self):
        return _odb_py.dbNetTrack_getLayer(self)

    @staticmethod
    def create(net, layer, box):
        return _odb_py.dbNetTrack_create(net, layer, box)

    @staticmethod
    def getNetTrack(block, dbid):
        return _odb_py.dbNetTrack_getNetTrack(block, dbid)

    @staticmethod
    def destroy(guide):
        return _odb_py.dbNetTrack_destroy(guide)

    def __init__(self):
        _odb_py.dbNetTrack_swiginit(self, _odb_py.new_dbNetTrack())
    __swig_destroy__ = _odb_py.delete_dbNetTrack

# Register dbNetTrack in _odb_py:
_odb_py.dbNetTrack_swigregister(dbNetTrack)

def dbNetTrack_create(net, layer, box):
    return _odb_py.dbNetTrack_create(net, layer, box)

def dbNetTrack_getNetTrack(block, dbid):
    return _odb_py.dbNetTrack_getNetTrack(block, dbid)

def dbNetTrack_destroy(guide):
    return _odb_py.dbNetTrack_destroy(guide)

class dbPowerDomain(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbPowerDomain_getName(self)

    def getGroup(self):
        return _odb_py.dbPowerDomain_getGroup(self)

    def setTop(self, top):
        return _odb_py.dbPowerDomain_setTop(self, top)

    def isTop(self):
        return _odb_py.dbPowerDomain_isTop(self)

    def setParent(self, parent):
        return _odb_py.dbPowerDomain_setParent(self, parent)

    def getParent(self):
        return _odb_py.dbPowerDomain_getParent(self)

    def setVoltage(self, voltage):
        return _odb_py.dbPowerDomain_setVoltage(self, voltage)

    def getVoltage(self):
        return _odb_py.dbPowerDomain_getVoltage(self)

    def setGroup(self, group):
        return _odb_py.dbPowerDomain_setGroup(self, group)

    @staticmethod
    def create(block, name):
        return _odb_py.dbPowerDomain_create(block, name)

    @staticmethod
    def destroy(pd):
        return _odb_py.dbPowerDomain_destroy(pd)

    def addElement(self, element):
        return _odb_py.dbPowerDomain_addElement(self, element)

    def getElements(self):
        return _odb_py.dbPowerDomain_getElements(self)

    def addPowerSwitch(self, ps):
        return _odb_py.dbPowerDomain_addPowerSwitch(self, ps)

    def addIsolation(self, iso):
        return _odb_py.dbPowerDomain_addIsolation(self, iso)

    def addLevelShifter(self, shifter):
        return _odb_py.dbPowerDomain_addLevelShifter(self, shifter)

    def getPowerSwitches(self):
        return _odb_py.dbPowerDomain_getPowerSwitches(self)

    def getIsolations(self):
        return _odb_py.dbPowerDomain_getIsolations(self)

    def getLevelShifters(self):
        return _odb_py.dbPowerDomain_getLevelShifters(self)

    def setArea(self, x1, y1, x2, y2):
        return _odb_py.dbPowerDomain_setArea(self, x1, y1, x2, y2)

    def getArea(self, x1, y1, x2, y2):
        return _odb_py.dbPowerDomain_getArea(self, x1, y1, x2, y2)

    def __init__(self):
        _odb_py.dbPowerDomain_swiginit(self, _odb_py.new_dbPowerDomain())
    __swig_destroy__ = _odb_py.delete_dbPowerDomain

# Register dbPowerDomain in _odb_py:
_odb_py.dbPowerDomain_swigregister(dbPowerDomain)

def dbPowerDomain_create(block, name):
    return _odb_py.dbPowerDomain_create(block, name)

def dbPowerDomain_destroy(pd):
    return _odb_py.dbPowerDomain_destroy(pd)

class dbPowerSwitch(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbPowerSwitch_getName(self)

    def setPowerDomain(self, power_domain):
        return _odb_py.dbPowerSwitch_setPowerDomain(self, power_domain)

    def getPowerDomain(self):
        return _odb_py.dbPowerSwitch_getPowerDomain(self)

    @staticmethod
    def create(block, name):
        return _odb_py.dbPowerSwitch_create(block, name)

    @staticmethod
    def destroy(ps):
        return _odb_py.dbPowerSwitch_destroy(ps)

    def addInSupplyPort(self, in_port, net):
        return _odb_py.dbPowerSwitch_addInSupplyPort(self, in_port, net)

    def setOutSupplyPort(self, out_port, net):
        return _odb_py.dbPowerSwitch_setOutSupplyPort(self, out_port, net)

    def addControlPort(self, control_port, control_net):
        return _odb_py.dbPowerSwitch_addControlPort(self, control_port, control_net)

    def addAcknowledgePort(self, port_name, net_name, boolean_expression):
        return _odb_py.dbPowerSwitch_addAcknowledgePort(self, port_name, net_name, boolean_expression)

    def addOnState(self, on_state, port_name, boolean_expression):
        return _odb_py.dbPowerSwitch_addOnState(self, on_state, port_name, boolean_expression)

    def setLibCell(self, master):
        return _odb_py.dbPowerSwitch_setLibCell(self, master)

    def addPortMap(self, *args):
        return _odb_py.dbPowerSwitch_addPortMap(self, *args)

    def getControlPorts(self):
        return _odb_py.dbPowerSwitch_getControlPorts(self)

    def getInputSupplyPorts(self):
        return _odb_py.dbPowerSwitch_getInputSupplyPorts(self)

    def getOutputSupplyPort(self):
        return _odb_py.dbPowerSwitch_getOutputSupplyPort(self)

    def getAcknowledgePorts(self):
        return _odb_py.dbPowerSwitch_getAcknowledgePorts(self)

    def getOnStates(self):
        return _odb_py.dbPowerSwitch_getOnStates(self)

    def getLibCell(self):
        return _odb_py.dbPowerSwitch_getLibCell(self)

    def getPortMap(self):
        return _odb_py.dbPowerSwitch_getPortMap(self)

    def __init__(self):
        _odb_py.dbPowerSwitch_swiginit(self, _odb_py.new_dbPowerSwitch())
    __swig_destroy__ = _odb_py.delete_dbPowerSwitch

# Register dbPowerSwitch in _odb_py:
_odb_py.dbPowerSwitch_swigregister(dbPowerSwitch)

def dbPowerSwitch_create(block, name):
    return _odb_py.dbPowerSwitch_create(block, name)

def dbPowerSwitch_destroy(ps):
    return _odb_py.dbPowerSwitch_destroy(ps)

class dbScanChain(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getScanPartitions(self):
        return _odb_py.dbScanChain_getScanPartitions(self)

    def getName(self):
        return _odb_py.dbScanChain_getName(self)

    def setName(self, name):
        return _odb_py.dbScanChain_setName(self, name)

    def setScanIn(self, *args):
        return _odb_py.dbScanChain_setScanIn(self, *args)

    def getScanIn(self):
        return _odb_py.dbScanChain_getScanIn(self)

    def setScanOut(self, *args):
        return _odb_py.dbScanChain_setScanOut(self, *args)

    def getScanOut(self):
        return _odb_py.dbScanChain_getScanOut(self)

    def setScanEnable(self, *args):
        return _odb_py.dbScanChain_setScanEnable(self, *args)

    def getScanEnable(self):
        return _odb_py.dbScanChain_getScanEnable(self)

    def setTestMode(self, *args):
        return _odb_py.dbScanChain_setTestMode(self, *args)

    def getTestMode(self):
        return _odb_py.dbScanChain_getTestMode(self)

    def setTestModeName(self, test_mode_name):
        return _odb_py.dbScanChain_setTestModeName(self, test_mode_name)

    def getTestModeName(self):
        return _odb_py.dbScanChain_getTestModeName(self)

    @staticmethod
    def create(dft):
        return _odb_py.dbScanChain_create(dft)

    def __init__(self):
        _odb_py.dbScanChain_swiginit(self, _odb_py.new_dbScanChain())
    __swig_destroy__ = _odb_py.delete_dbScanChain

# Register dbScanChain in _odb_py:
_odb_py.dbScanChain_swigregister(dbScanChain)

def dbScanChain_create(dft):
    return _odb_py.dbScanChain_create(dft)

class dbScanInst(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ClockEdge_Rising = _odb_py.dbScanInst_ClockEdge_Rising
    ClockEdge_Falling = _odb_py.dbScanInst_ClockEdge_Falling

    def setScanClock(self, scan_clock):
        return _odb_py.dbScanInst_setScanClock(self, scan_clock)

    def getScanClock(self):
        return _odb_py.dbScanInst_getScanClock(self)

    def setClockEdge(self, clock_edge):
        return _odb_py.dbScanInst_setClockEdge(self, clock_edge)

    def getClockEdge(self):
        return _odb_py.dbScanInst_getClockEdge(self)

    def setBits(self, bits):
        return _odb_py.dbScanInst_setBits(self, bits)

    def getBits(self):
        return _odb_py.dbScanInst_getBits(self)

    def setScanEnable(self, *args):
        return _odb_py.dbScanInst_setScanEnable(self, *args)

    def getScanEnable(self):
        return _odb_py.dbScanInst_getScanEnable(self)

    def setAccessPins(self, access_pins):
        return _odb_py.dbScanInst_setAccessPins(self, access_pins)

    def getAccessPins(self):
        return _odb_py.dbScanInst_getAccessPins(self)

    def getInst(self):
        return _odb_py.dbScanInst_getInst(self)

    @staticmethod
    def create(scan_list, inst):
        return _odb_py.dbScanInst_create(scan_list, inst)

    def __init__(self):
        _odb_py.dbScanInst_swiginit(self, _odb_py.new_dbScanInst())
    __swig_destroy__ = _odb_py.delete_dbScanInst

# Register dbScanInst in _odb_py:
_odb_py.dbScanInst_swigregister(dbScanInst)

def dbScanInst_create(scan_list, inst):
    return _odb_py.dbScanInst_create(scan_list, inst)

class dbScanList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getScanInsts(self):
        return _odb_py.dbScanList_getScanInsts(self)

    def add(self, inst):
        return _odb_py.dbScanList_add(self, inst)

    @staticmethod
    def create(scan_partition):
        return _odb_py.dbScanList_create(scan_partition)

    def __init__(self):
        _odb_py.dbScanList_swiginit(self, _odb_py.new_dbScanList())
    __swig_destroy__ = _odb_py.delete_dbScanList

# Register dbScanList in _odb_py:
_odb_py.dbScanList_swigregister(dbScanList)

def dbScanList_create(scan_partition):
    return _odb_py.dbScanList_create(scan_partition)

class dbScanPartition(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getScanLists(self):
        return _odb_py.dbScanPartition_getScanLists(self)

    def getName(self):
        return _odb_py.dbScanPartition_getName(self)

    def setName(self, name):
        return _odb_py.dbScanPartition_setName(self, name)

    @staticmethod
    def create(chain):
        return _odb_py.dbScanPartition_create(chain)

    def __init__(self):
        _odb_py.dbScanPartition_swiginit(self, _odb_py.new_dbScanPartition())
    __swig_destroy__ = _odb_py.delete_dbScanPartition

# Register dbScanPartition in _odb_py:
_odb_py.dbScanPartition_swigregister(dbScanPartition)

def dbScanPartition_create(chain):
    return _odb_py.dbScanPartition_create(chain)

class dbScanPin(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getPin(self):
        return _odb_py.dbScanPin_getPin(self)

    def setPin(self, *args):
        return _odb_py.dbScanPin_setPin(self, *args)

    @staticmethod
    def create(*args):
        return _odb_py.dbScanPin_create(*args)

    def __init__(self):
        _odb_py.dbScanPin_swiginit(self, _odb_py.new_dbScanPin())
    __swig_destroy__ = _odb_py.delete_dbScanPin

# Register dbScanPin in _odb_py:
_odb_py.dbScanPin_swigregister(dbScanPin)

def dbScanPin_create(*args):
    return _odb_py.dbScanPin_create(*args)

class dbTechLayer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NONE = _odb_py.dbTechLayer_NONE
    NWELL = _odb_py.dbTechLayer_NWELL
    PWELL = _odb_py.dbTechLayer_PWELL
    ABOVEDIEEDGE = _odb_py.dbTechLayer_ABOVEDIEEDGE
    BELOWDIEEDGE = _odb_py.dbTechLayer_BELOWDIEEDGE
    DIFFUSION = _odb_py.dbTechLayer_DIFFUSION
    TRIMPOLY = _odb_py.dbTechLayer_TRIMPOLY
    MIMCAP = _odb_py.dbTechLayer_MIMCAP
    STACKEDMIMCAP = _odb_py.dbTechLayer_STACKEDMIMCAP
    TSVMETAL = _odb_py.dbTechLayer_TSVMETAL
    TSV = _odb_py.dbTechLayer_TSV
    PASSIVATION = _odb_py.dbTechLayer_PASSIVATION
    HIGHR = _odb_py.dbTechLayer_HIGHR
    TRIMMETAL = _odb_py.dbTechLayer_TRIMMETAL
    REGION = _odb_py.dbTechLayer_REGION
    MEOL = _odb_py.dbTechLayer_MEOL
    WELLDISTANCE = _odb_py.dbTechLayer_WELLDISTANCE
    CPODE = _odb_py.dbTechLayer_CPODE
    PADMETAL = _odb_py.dbTechLayer_PADMETAL
    POLYROUTING = _odb_py.dbTechLayer_POLYROUTING

    def setWrongWayWidth(self, wrong_way_width):
        return _odb_py.dbTechLayer_setWrongWayWidth(self, wrong_way_width)

    def getWrongWayWidth(self):
        return _odb_py.dbTechLayer_getWrongWayWidth(self)

    def setLayerAdjustment(self, layer_adjustment):
        return _odb_py.dbTechLayer_setLayerAdjustment(self, layer_adjustment)

    def getLayerAdjustment(self):
        return _odb_py.dbTechLayer_getLayerAdjustment(self)

    def getTechLayerCutClassRules(self):
        return _odb_py.dbTechLayer_getTechLayerCutClassRules(self)

    def findTechLayerCutClassRule(self, name):
        return _odb_py.dbTechLayer_findTechLayerCutClassRule(self, name)

    def getTechLayerSpacingEolRules(self):
        return _odb_py.dbTechLayer_getTechLayerSpacingEolRules(self)

    def getTechLayerCutSpacingRules(self):
        return _odb_py.dbTechLayer_getTechLayerCutSpacingRules(self)

    def getTechLayerMinStepRules(self):
        return _odb_py.dbTechLayer_getTechLayerMinStepRules(self)

    def getTechLayerCornerSpacingRules(self):
        return _odb_py.dbTechLayer_getTechLayerCornerSpacingRules(self)

    def getTechLayerSpacingTablePrlRules(self):
        return _odb_py.dbTechLayer_getTechLayerSpacingTablePrlRules(self)

    def getTechLayerCutSpacingTableOrthRules(self):
        return _odb_py.dbTechLayer_getTechLayerCutSpacingTableOrthRules(self)

    def getTechLayerCutSpacingTableDefRules(self):
        return _odb_py.dbTechLayer_getTechLayerCutSpacingTableDefRules(self)

    def getTechLayerCutEnclosureRules(self):
        return _odb_py.dbTechLayer_getTechLayerCutEnclosureRules(self)

    def getTechLayerEolExtensionRules(self):
        return _odb_py.dbTechLayer_getTechLayerEolExtensionRules(self)

    def getTechLayerArraySpacingRules(self):
        return _odb_py.dbTechLayer_getTechLayerArraySpacingRules(self)

    def getTechLayerEolKeepOutRules(self):
        return _odb_py.dbTechLayer_getTechLayerEolKeepOutRules(self)

    def getTechLayerWidthTableRules(self):
        return _odb_py.dbTechLayer_getTechLayerWidthTableRules(self)

    def getTechLayerMinCutRules(self):
        return _odb_py.dbTechLayer_getTechLayerMinCutRules(self)

    def getTechLayerAreaRules(self):
        return _odb_py.dbTechLayer_getTechLayerAreaRules(self)

    def getTechLayerForbiddenSpacingRules(self):
        return _odb_py.dbTechLayer_getTechLayerForbiddenSpacingRules(self)

    def getTechLayerKeepOutZoneRules(self):
        return _odb_py.dbTechLayer_getTechLayerKeepOutZoneRules(self)

    def getTechLayerWrongDirSpacingRules(self):
        return _odb_py.dbTechLayer_getTechLayerWrongDirSpacingRules(self)

    def getTechLayerTwoWiresForbiddenSpcRules(self):
        return _odb_py.dbTechLayer_getTechLayerTwoWiresForbiddenSpcRules(self)

    def setRectOnly(self, rect_only):
        return _odb_py.dbTechLayer_setRectOnly(self, rect_only)

    def isRectOnly(self):
        return _odb_py.dbTechLayer_isRectOnly(self)

    def setRightWayOnGridOnly(self, right_way_on_grid_only):
        return _odb_py.dbTechLayer_setRightWayOnGridOnly(self, right_way_on_grid_only)

    def isRightWayOnGridOnly(self):
        return _odb_py.dbTechLayer_isRightWayOnGridOnly(self)

    def setRightWayOnGridOnlyCheckMask(self, right_way_on_grid_only_check_mask):
        return _odb_py.dbTechLayer_setRightWayOnGridOnlyCheckMask(self, right_way_on_grid_only_check_mask)

    def isRightWayOnGridOnlyCheckMask(self):
        return _odb_py.dbTechLayer_isRightWayOnGridOnlyCheckMask(self)

    def setRectOnlyExceptNonCorePins(self, rect_only_except_non_core_pins):
        return _odb_py.dbTechLayer_setRectOnlyExceptNonCorePins(self, rect_only_except_non_core_pins)

    def isRectOnlyExceptNonCorePins(self):
        return _odb_py.dbTechLayer_isRectOnlyExceptNonCorePins(self)

    def findV55Spacing(self, width, prl):
        return _odb_py.dbTechLayer_findV55Spacing(self, width, prl)

    def findTwSpacing(self, width1, width2, prl):
        return _odb_py.dbTechLayer_findTwSpacing(self, width1, width2, prl)

    def setLef58Type(self, type):
        return _odb_py.dbTechLayer_setLef58Type(self, type)

    def getLef58Type(self):
        return _odb_py.dbTechLayer_getLef58Type(self)

    def getLef58TypeString(self):
        return _odb_py.dbTechLayer_getLef58TypeString(self)

    def getName(self):
        return _odb_py.dbTechLayer_getName(self)

    def getConstName(self):
        return _odb_py.dbTechLayer_getConstName(self)

    def hasAlias(self):
        return _odb_py.dbTechLayer_hasAlias(self)

    def getAlias(self):
        return _odb_py.dbTechLayer_getAlias(self)

    def setAlias(self, alias):
        return _odb_py.dbTechLayer_setAlias(self, alias)

    def getWidth(self):
        return _odb_py.dbTechLayer_getWidth(self)

    def setWidth(self, width):
        return _odb_py.dbTechLayer_setWidth(self, width)

    def setSpacing(self, spacing):
        return _odb_py.dbTechLayer_setSpacing(self, spacing)

    def getSpacing(self, *args):
        return _odb_py.dbTechLayer_getSpacing(self, *args)

    def getNumMasks(self):
        return _odb_py.dbTechLayer_getNumMasks(self)

    def setNumMasks(self, number):
        return _odb_py.dbTechLayer_setNumMasks(self, number)

    def getMaxWideDRCRange(self, owidth, olength):
        return _odb_py.dbTechLayer_getMaxWideDRCRange(self, owidth, olength)

    def getMinWideDRCRange(self, owidth, olength):
        return _odb_py.dbTechLayer_getMinWideDRCRange(self, owidth, olength)

    def getV54SpacingRules(self):
        return _odb_py.dbTechLayer_getV54SpacingRules(self)

    def hasV55SpacingRules(self):
        return _odb_py.dbTechLayer_hasV55SpacingRules(self)

    def getV55SpacingWidthsAndLengths(self, width_idx, length_idx):
        return _odb_py.dbTechLayer_getV55SpacingWidthsAndLengths(self, width_idx, length_idx)

    def printV55SpacingRules(self, writer):
        return _odb_py.dbTechLayer_printV55SpacingRules(self, writer)

    def getV55SpacingTable(self, sptbl):
        return _odb_py.dbTechLayer_getV55SpacingTable(self, sptbl)

    def initV55LengthIndex(self, numelems):
        return _odb_py.dbTechLayer_initV55LengthIndex(self, numelems)

    def addV55LengthEntry(self, length):
        return _odb_py.dbTechLayer_addV55LengthEntry(self, length)

    def initV55WidthIndex(self, numelems):
        return _odb_py.dbTechLayer_initV55WidthIndex(self, numelems)

    def addV55WidthEntry(self, width):
        return _odb_py.dbTechLayer_addV55WidthEntry(self, width)

    def initV55SpacingTable(self, numrows, numcols):
        return _odb_py.dbTechLayer_initV55SpacingTable(self, numrows, numcols)

    def addV55SpacingTableEntry(self, inrow, incol, spacing):
        return _odb_py.dbTechLayer_addV55SpacingTableEntry(self, inrow, incol, spacing)

    def getV55InfluenceRules(self):
        return _odb_py.dbTechLayer_getV55InfluenceRules(self)

    def hasTwoWidthsSpacingRules(self):
        return _odb_py.dbTechLayer_hasTwoWidthsSpacingRules(self)

    def printTwoWidthsSpacingRules(self, writer):
        return _odb_py.dbTechLayer_printTwoWidthsSpacingRules(self, writer)

    def getTwoWidthsSpacingTable(self, sptbl):
        return _odb_py.dbTechLayer_getTwoWidthsSpacingTable(self, sptbl)

    def getTwoWidthsSpacingTableNumWidths(self):
        return _odb_py.dbTechLayer_getTwoWidthsSpacingTableNumWidths(self)

    def getTwoWidthsSpacingTableWidth(self, row):
        return _odb_py.dbTechLayer_getTwoWidthsSpacingTableWidth(self, row)

    def getTwoWidthsSpacingTableHasPRL(self, row):
        return _odb_py.dbTechLayer_getTwoWidthsSpacingTableHasPRL(self, row)

    def getTwoWidthsSpacingTablePRL(self, row):
        return _odb_py.dbTechLayer_getTwoWidthsSpacingTablePRL(self, row)

    def getTwoWidthsSpacingTableEntry(self, row, col):
        return _odb_py.dbTechLayer_getTwoWidthsSpacingTableEntry(self, row, col)

    def initTwoWidths(self, num_widths):
        return _odb_py.dbTechLayer_initTwoWidths(self, num_widths)

    def addTwoWidthsIndexEntry(self, width, parallel_run_length=-1):
        return _odb_py.dbTechLayer_addTwoWidthsIndexEntry(self, width, parallel_run_length)

    def addTwoWidthsSpacingTableEntry(self, inrow, incol, spacing):
        return _odb_py.dbTechLayer_addTwoWidthsSpacingTableEntry(self, inrow, incol, spacing)

    def createDefaultAntennaRule(self):
        return _odb_py.dbTechLayer_createDefaultAntennaRule(self)

    def createOxide2AntennaRule(self):
        return _odb_py.dbTechLayer_createOxide2AntennaRule(self)

    def hasDefaultAntennaRule(self):
        return _odb_py.dbTechLayer_hasDefaultAntennaRule(self)

    def hasOxide2AntennaRule(self):
        return _odb_py.dbTechLayer_hasOxide2AntennaRule(self)

    def getDefaultAntennaRule(self):
        return _odb_py.dbTechLayer_getDefaultAntennaRule(self)

    def getOxide2AntennaRule(self):
        return _odb_py.dbTechLayer_getOxide2AntennaRule(self)

    def writeAntennaRulesLef(self, writer):
        return _odb_py.dbTechLayer_writeAntennaRulesLef(self, writer)

    def getMinimumCutRules(self, cut_rules):
        return _odb_py.dbTechLayer_getMinimumCutRules(self, cut_rules)

    def getMinEnclosureRules(self, enc_rules):
        return _odb_py.dbTechLayer_getMinEnclosureRules(self, enc_rules)

    def getMinCutRules(self):
        return _odb_py.dbTechLayer_getMinCutRules(self)

    def getMinEncRules(self):
        return _odb_py.dbTechLayer_getMinEncRules(self)

    def getPitch(self):
        return _odb_py.dbTechLayer_getPitch(self)

    def getPitchX(self):
        return _odb_py.dbTechLayer_getPitchX(self)

    def getPitchY(self):
        return _odb_py.dbTechLayer_getPitchY(self)

    def getFirstLastPitch(self):
        return _odb_py.dbTechLayer_getFirstLastPitch(self)

    def setPitch(self, pitch):
        return _odb_py.dbTechLayer_setPitch(self, pitch)

    def setPitchXY(self, pitch_x, pitch_y):
        return _odb_py.dbTechLayer_setPitchXY(self, pitch_x, pitch_y)

    def setFirstLastPitch(self, first_last_pitch):
        return _odb_py.dbTechLayer_setFirstLastPitch(self, first_last_pitch)

    def hasXYPitch(self):
        return _odb_py.dbTechLayer_hasXYPitch(self)

    def getOffset(self):
        return _odb_py.dbTechLayer_getOffset(self)

    def getOffsetX(self):
        return _odb_py.dbTechLayer_getOffsetX(self)

    def getOffsetY(self):
        return _odb_py.dbTechLayer_getOffsetY(self)

    def setOffset(self, pitch):
        return _odb_py.dbTechLayer_setOffset(self, pitch)

    def setOffsetXY(self, pitch_x, pitch_y):
        return _odb_py.dbTechLayer_setOffsetXY(self, pitch_x, pitch_y)

    def hasXYOffset(self):
        return _odb_py.dbTechLayer_hasXYOffset(self)

    def getThickness(self, inthk):
        return _odb_py.dbTechLayer_getThickness(self, inthk)

    def setThickness(self, thickness):
        return _odb_py.dbTechLayer_setThickness(self, thickness)

    def hasArea(self):
        return _odb_py.dbTechLayer_hasArea(self)

    def getArea(self):
        return _odb_py.dbTechLayer_getArea(self)

    def setArea(self, area):
        return _odb_py.dbTechLayer_setArea(self, area)

    def hasMaxWidth(self):
        return _odb_py.dbTechLayer_hasMaxWidth(self)

    def getMaxWidth(self):
        return _odb_py.dbTechLayer_getMaxWidth(self)

    def setMaxWidth(self, max_width):
        return _odb_py.dbTechLayer_setMaxWidth(self, max_width)

    def getMinWidth(self):
        return _odb_py.dbTechLayer_getMinWidth(self)

    def setMinWidth(self, max_width):
        return _odb_py.dbTechLayer_setMinWidth(self, max_width)

    def hasMinStep(self):
        return _odb_py.dbTechLayer_hasMinStep(self)

    def getMinStep(self):
        return _odb_py.dbTechLayer_getMinStep(self)

    def setMinStep(self, min_step):
        return _odb_py.dbTechLayer_setMinStep(self, min_step)

    def getMinStepType(self):
        return _odb_py.dbTechLayer_getMinStepType(self)

    def setMinStepType(self, type):
        return _odb_py.dbTechLayer_setMinStepType(self, type)

    def hasMinStepMaxLength(self):
        return _odb_py.dbTechLayer_hasMinStepMaxLength(self)

    def getMinStepMaxLength(self):
        return _odb_py.dbTechLayer_getMinStepMaxLength(self)

    def setMinStepMaxLength(self, length):
        return _odb_py.dbTechLayer_setMinStepMaxLength(self, length)

    def hasMinStepMaxEdges(self):
        return _odb_py.dbTechLayer_hasMinStepMaxEdges(self)

    def getMinStepMaxEdges(self):
        return _odb_py.dbTechLayer_getMinStepMaxEdges(self)

    def setMinStepMaxEdges(self, edges):
        return _odb_py.dbTechLayer_setMinStepMaxEdges(self, edges)

    def hasProtrusion(self):
        return _odb_py.dbTechLayer_hasProtrusion(self)

    def getProtrusionWidth(self):
        return _odb_py.dbTechLayer_getProtrusionWidth(self)

    def getProtrusionLength(self):
        return _odb_py.dbTechLayer_getProtrusionLength(self)

    def getProtrusionFromWidth(self):
        return _odb_py.dbTechLayer_getProtrusionFromWidth(self)

    def setProtrusion(self, pt_width, pt_length, pt_from_width):
        return _odb_py.dbTechLayer_setProtrusion(self, pt_width, pt_length, pt_from_width)

    def getType(self):
        return _odb_py.dbTechLayer_getType(self)

    def getDirection(self):
        return _odb_py.dbTechLayer_getDirection(self)

    def setDirection(self, direction):
        return _odb_py.dbTechLayer_setDirection(self, direction)

    def getResistance(self):
        return _odb_py.dbTechLayer_getResistance(self)

    def setResistance(self, res):
        return _odb_py.dbTechLayer_setResistance(self, res)

    def getCapacitance(self):
        return _odb_py.dbTechLayer_getCapacitance(self)

    def setCapacitance(self, cap):
        return _odb_py.dbTechLayer_setCapacitance(self, cap)

    def getEdgeCapacitance(self):
        return _odb_py.dbTechLayer_getEdgeCapacitance(self)

    def setEdgeCapacitance(self, cap):
        return _odb_py.dbTechLayer_setEdgeCapacitance(self, cap)

    def getWireExtension(self):
        return _odb_py.dbTechLayer_getWireExtension(self)

    def setWireExtension(self, ext):
        return _odb_py.dbTechLayer_setWireExtension(self, ext)

    def getNumber(self):
        return _odb_py.dbTechLayer_getNumber(self)

    def getRoutingLevel(self):
        return _odb_py.dbTechLayer_getRoutingLevel(self)

    def getLowerLayer(self):
        return _odb_py.dbTechLayer_getLowerLayer(self)

    def getUpperLayer(self):
        return _odb_py.dbTechLayer_getUpperLayer(self)

    def getTech(self):
        return _odb_py.dbTechLayer_getTech(self)

    @staticmethod
    def create(tech, name, type):
        return _odb_py.dbTechLayer_create(tech, name, type)

    @staticmethod
    def getTechLayer(tech, oid):
        return _odb_py.dbTechLayer_getTechLayer(tech, oid)

    def __init__(self):
        _odb_py.dbTechLayer_swiginit(self, _odb_py.new_dbTechLayer())
    __swig_destroy__ = _odb_py.delete_dbTechLayer

# Register dbTechLayer in _odb_py:
_odb_py.dbTechLayer_swigregister(dbTechLayer)

def dbTechLayer_create(tech, name, type):
    return _odb_py.dbTechLayer_create(tech, name, type)

def dbTechLayer_getTechLayer(tech, oid):
    return _odb_py.dbTechLayer_getTechLayer(tech, oid)

class dbTechLayerAreaRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setArea(self, area):
        return _odb_py.dbTechLayerAreaRule_setArea(self, area)

    def getArea(self):
        return _odb_py.dbTechLayerAreaRule_getArea(self)

    def setExceptMinWidth(self, except_min_width):
        return _odb_py.dbTechLayerAreaRule_setExceptMinWidth(self, except_min_width)

    def getExceptMinWidth(self):
        return _odb_py.dbTechLayerAreaRule_getExceptMinWidth(self)

    def setExceptEdgeLength(self, except_edge_length):
        return _odb_py.dbTechLayerAreaRule_setExceptEdgeLength(self, except_edge_length)

    def getExceptEdgeLength(self):
        return _odb_py.dbTechLayerAreaRule_getExceptEdgeLength(self)

    def setExceptEdgeLengths(self, except_edge_lengths):
        return _odb_py.dbTechLayerAreaRule_setExceptEdgeLengths(self, except_edge_lengths)

    def getExceptEdgeLengths(self):
        return _odb_py.dbTechLayerAreaRule_getExceptEdgeLengths(self)

    def setExceptMinSize(self, except_min_size):
        return _odb_py.dbTechLayerAreaRule_setExceptMinSize(self, except_min_size)

    def getExceptMinSize(self):
        return _odb_py.dbTechLayerAreaRule_getExceptMinSize(self)

    def setExceptStep(self, except_step):
        return _odb_py.dbTechLayerAreaRule_setExceptStep(self, except_step)

    def getExceptStep(self):
        return _odb_py.dbTechLayerAreaRule_getExceptStep(self)

    def setMask(self, mask):
        return _odb_py.dbTechLayerAreaRule_setMask(self, mask)

    def getMask(self):
        return _odb_py.dbTechLayerAreaRule_getMask(self)

    def setRectWidth(self, rect_width):
        return _odb_py.dbTechLayerAreaRule_setRectWidth(self, rect_width)

    def getRectWidth(self):
        return _odb_py.dbTechLayerAreaRule_getRectWidth(self)

    def setExceptRectangle(self, except_rectangle):
        return _odb_py.dbTechLayerAreaRule_setExceptRectangle(self, except_rectangle)

    def isExceptRectangle(self):
        return _odb_py.dbTechLayerAreaRule_isExceptRectangle(self)

    def setOverlap(self, overlap):
        return _odb_py.dbTechLayerAreaRule_setOverlap(self, overlap)

    def getOverlap(self):
        return _odb_py.dbTechLayerAreaRule_getOverlap(self)

    @staticmethod
    def create(_layer):
        return _odb_py.dbTechLayerAreaRule_create(_layer)

    def setTrimLayer(self, trim_layer):
        return _odb_py.dbTechLayerAreaRule_setTrimLayer(self, trim_layer)

    def getTrimLayer(self):
        return _odb_py.dbTechLayerAreaRule_getTrimLayer(self)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerAreaRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerAreaRule_swiginit(self, _odb_py.new_dbTechLayerAreaRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerAreaRule

# Register dbTechLayerAreaRule in _odb_py:
_odb_py.dbTechLayerAreaRule_swigregister(dbTechLayerAreaRule)

def dbTechLayerAreaRule_create(_layer):
    return _odb_py.dbTechLayerAreaRule_create(_layer)

def dbTechLayerAreaRule_destroy(rule):
    return _odb_py.dbTechLayerAreaRule_destroy(rule)

class dbTechLayerArraySpacingRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setViaWidth(self, via_width):
        return _odb_py.dbTechLayerArraySpacingRule_setViaWidth(self, via_width)

    def getViaWidth(self):
        return _odb_py.dbTechLayerArraySpacingRule_getViaWidth(self)

    def setCutSpacing(self, cut_spacing):
        return _odb_py.dbTechLayerArraySpacingRule_setCutSpacing(self, cut_spacing)

    def getCutSpacing(self):
        return _odb_py.dbTechLayerArraySpacingRule_getCutSpacing(self)

    def setWithin(self, within):
        return _odb_py.dbTechLayerArraySpacingRule_setWithin(self, within)

    def getWithin(self):
        return _odb_py.dbTechLayerArraySpacingRule_getWithin(self)

    def setArrayWidth(self, array_width):
        return _odb_py.dbTechLayerArraySpacingRule_setArrayWidth(self, array_width)

    def getArrayWidth(self):
        return _odb_py.dbTechLayerArraySpacingRule_getArrayWidth(self)

    def setCutClass(self, cut_class):
        return _odb_py.dbTechLayerArraySpacingRule_setCutClass(self, cut_class)

    def setParallelOverlap(self, parallel_overlap):
        return _odb_py.dbTechLayerArraySpacingRule_setParallelOverlap(self, parallel_overlap)

    def isParallelOverlap(self):
        return _odb_py.dbTechLayerArraySpacingRule_isParallelOverlap(self)

    def setLongArray(self, long_array):
        return _odb_py.dbTechLayerArraySpacingRule_setLongArray(self, long_array)

    def isLongArray(self):
        return _odb_py.dbTechLayerArraySpacingRule_isLongArray(self)

    def setViaWidthValid(self, via_width_valid):
        return _odb_py.dbTechLayerArraySpacingRule_setViaWidthValid(self, via_width_valid)

    def isViaWidthValid(self):
        return _odb_py.dbTechLayerArraySpacingRule_isViaWidthValid(self)

    def setWithinValid(self, within_valid):
        return _odb_py.dbTechLayerArraySpacingRule_setWithinValid(self, within_valid)

    def isWithinValid(self):
        return _odb_py.dbTechLayerArraySpacingRule_isWithinValid(self)

    def setCutsArraySpacing(self, num_cuts, spacing):
        return _odb_py.dbTechLayerArraySpacingRule_setCutsArraySpacing(self, num_cuts, spacing)

    def getCutsArraySpacing(self):
        return _odb_py.dbTechLayerArraySpacingRule_getCutsArraySpacing(self)

    def getCutClass(self):
        return _odb_py.dbTechLayerArraySpacingRule_getCutClass(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerArraySpacingRule_create(layer)

    @staticmethod
    def getTechLayerArraySpacingRule(inly, dbid):
        return _odb_py.dbTechLayerArraySpacingRule_getTechLayerArraySpacingRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerArraySpacingRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerArraySpacingRule_swiginit(self, _odb_py.new_dbTechLayerArraySpacingRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerArraySpacingRule

# Register dbTechLayerArraySpacingRule in _odb_py:
_odb_py.dbTechLayerArraySpacingRule_swigregister(dbTechLayerArraySpacingRule)

def dbTechLayerArraySpacingRule_create(layer):
    return _odb_py.dbTechLayerArraySpacingRule_create(layer)

def dbTechLayerArraySpacingRule_getTechLayerArraySpacingRule(inly, dbid):
    return _odb_py.dbTechLayerArraySpacingRule_getTechLayerArraySpacingRule(inly, dbid)

def dbTechLayerArraySpacingRule_destroy(rule):
    return _odb_py.dbTechLayerArraySpacingRule_destroy(rule)

class dbTechLayerCornerSpacingRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CONVEXCORNER = _odb_py.dbTechLayerCornerSpacingRule_CONVEXCORNER
    CONCAVECORNER = _odb_py.dbTechLayerCornerSpacingRule_CONCAVECORNER

    def setWithin(self, within):
        return _odb_py.dbTechLayerCornerSpacingRule_setWithin(self, within)

    def getWithin(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getWithin(self)

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerCornerSpacingRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getEolWidth(self)

    def setJogLength(self, jog_length):
        return _odb_py.dbTechLayerCornerSpacingRule_setJogLength(self, jog_length)

    def getJogLength(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getJogLength(self)

    def setEdgeLength(self, edge_length):
        return _odb_py.dbTechLayerCornerSpacingRule_setEdgeLength(self, edge_length)

    def getEdgeLength(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getEdgeLength(self)

    def setMinLength(self, min_length):
        return _odb_py.dbTechLayerCornerSpacingRule_setMinLength(self, min_length)

    def getMinLength(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getMinLength(self)

    def setExceptNotchLength(self, except_notch_length):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptNotchLength(self, except_notch_length)

    def getExceptNotchLength(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getExceptNotchLength(self)

    def setSameMask(self, same_mask):
        return _odb_py.dbTechLayerCornerSpacingRule_setSameMask(self, same_mask)

    def isSameMask(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isSameMask(self)

    def setCornerOnly(self, corner_only):
        return _odb_py.dbTechLayerCornerSpacingRule_setCornerOnly(self, corner_only)

    def isCornerOnly(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isCornerOnly(self)

    def setExceptEol(self, except_eol):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptEol(self, except_eol)

    def isExceptEol(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isExceptEol(self)

    def setExceptJogLength(self, except_jog_length):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptJogLength(self, except_jog_length)

    def isExceptJogLength(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isExceptJogLength(self)

    def setEdgeLengthValid(self, edge_length_valid):
        return _odb_py.dbTechLayerCornerSpacingRule_setEdgeLengthValid(self, edge_length_valid)

    def isEdgeLengthValid(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isEdgeLengthValid(self)

    def setIncludeShape(self, include_shape):
        return _odb_py.dbTechLayerCornerSpacingRule_setIncludeShape(self, include_shape)

    def isIncludeShape(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isIncludeShape(self)

    def setMinLengthValid(self, min_length_valid):
        return _odb_py.dbTechLayerCornerSpacingRule_setMinLengthValid(self, min_length_valid)

    def isMinLengthValid(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isMinLengthValid(self)

    def setExceptNotch(self, except_notch):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptNotch(self, except_notch)

    def isExceptNotch(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isExceptNotch(self)

    def setExceptNotchLengthValid(self, except_notch_length_valid):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptNotchLengthValid(self, except_notch_length_valid)

    def isExceptNotchLengthValid(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isExceptNotchLengthValid(self)

    def setExceptSameNet(self, except_same_net):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptSameNet(self, except_same_net)

    def isExceptSameNet(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isExceptSameNet(self)

    def setExceptSameMetal(self, except_same_metal):
        return _odb_py.dbTechLayerCornerSpacingRule_setExceptSameMetal(self, except_same_metal)

    def isExceptSameMetal(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isExceptSameMetal(self)

    def setCornerToCorner(self, corner_to_corner):
        return _odb_py.dbTechLayerCornerSpacingRule_setCornerToCorner(self, corner_to_corner)

    def isCornerToCorner(self):
        return _odb_py.dbTechLayerCornerSpacingRule_isCornerToCorner(self)

    def setType(self, _type):
        return _odb_py.dbTechLayerCornerSpacingRule_setType(self, _type)

    def getType(self):
        return _odb_py.dbTechLayerCornerSpacingRule_getType(self)

    def addSpacing(self, width, spacing1, spacing2=0):
        return _odb_py.dbTechLayerCornerSpacingRule_addSpacing(self, width, spacing1, spacing2)

    def getSpacingTable(self, tbl):
        return _odb_py.dbTechLayerCornerSpacingRule_getSpacingTable(self, tbl)

    def getWidthTable(self, tbl):
        return _odb_py.dbTechLayerCornerSpacingRule_getWidthTable(self, tbl)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerCornerSpacingRule_create(layer)

    @staticmethod
    def getTechLayerCornerSpacingRule(inly, dbid):
        return _odb_py.dbTechLayerCornerSpacingRule_getTechLayerCornerSpacingRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerCornerSpacingRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerCornerSpacingRule_swiginit(self, _odb_py.new_dbTechLayerCornerSpacingRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerCornerSpacingRule

# Register dbTechLayerCornerSpacingRule in _odb_py:
_odb_py.dbTechLayerCornerSpacingRule_swigregister(dbTechLayerCornerSpacingRule)

def dbTechLayerCornerSpacingRule_create(layer):
    return _odb_py.dbTechLayerCornerSpacingRule_create(layer)

def dbTechLayerCornerSpacingRule_getTechLayerCornerSpacingRule(inly, dbid):
    return _odb_py.dbTechLayerCornerSpacingRule_getTechLayerCornerSpacingRule(inly, dbid)

def dbTechLayerCornerSpacingRule_destroy(rule):
    return _odb_py.dbTechLayerCornerSpacingRule_destroy(rule)

class dbTechLayerCutClassRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getName(self):
        return _odb_py.dbTechLayerCutClassRule_getName(self)

    def setWidth(self, width):
        return _odb_py.dbTechLayerCutClassRule_setWidth(self, width)

    def getWidth(self):
        return _odb_py.dbTechLayerCutClassRule_getWidth(self)

    def setLength(self, length):
        return _odb_py.dbTechLayerCutClassRule_setLength(self, length)

    def getLength(self):
        return _odb_py.dbTechLayerCutClassRule_getLength(self)

    def setNumCuts(self, num_cuts):
        return _odb_py.dbTechLayerCutClassRule_setNumCuts(self, num_cuts)

    def getNumCuts(self):
        return _odb_py.dbTechLayerCutClassRule_getNumCuts(self)

    def setLengthValid(self, length_valid):
        return _odb_py.dbTechLayerCutClassRule_setLengthValid(self, length_valid)

    def isLengthValid(self):
        return _odb_py.dbTechLayerCutClassRule_isLengthValid(self)

    def setCutsValid(self, cuts_valid):
        return _odb_py.dbTechLayerCutClassRule_setCutsValid(self, cuts_valid)

    def isCutsValid(self):
        return _odb_py.dbTechLayerCutClassRule_isCutsValid(self)

    @staticmethod
    def getTechLayerCutClassRule(inly, dbid):
        return _odb_py.dbTechLayerCutClassRule_getTechLayerCutClassRule(inly, dbid)

    @staticmethod
    def create(_layer, name):
        return _odb_py.dbTechLayerCutClassRule_create(_layer, name)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerCutClassRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerCutClassRule_swiginit(self, _odb_py.new_dbTechLayerCutClassRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerCutClassRule

# Register dbTechLayerCutClassRule in _odb_py:
_odb_py.dbTechLayerCutClassRule_swigregister(dbTechLayerCutClassRule)

def dbTechLayerCutClassRule_getTechLayerCutClassRule(inly, dbid):
    return _odb_py.dbTechLayerCutClassRule_getTechLayerCutClassRule(inly, dbid)

def dbTechLayerCutClassRule_create(_layer, name):
    return _odb_py.dbTechLayerCutClassRule_create(_layer, name)

def dbTechLayerCutClassRule_destroy(rule):
    return _odb_py.dbTechLayerCutClassRule_destroy(rule)

class dbTechLayerCutEnclosureRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    DEFAULT = _odb_py.dbTechLayerCutEnclosureRule_DEFAULT
    EOL = _odb_py.dbTechLayerCutEnclosureRule_EOL
    ENDSIDE = _odb_py.dbTechLayerCutEnclosureRule_ENDSIDE
    HORZ_AND_VERT = _odb_py.dbTechLayerCutEnclosureRule_HORZ_AND_VERT

    def setCutClass(self, cut_class):
        return _odb_py.dbTechLayerCutEnclosureRule_setCutClass(self, cut_class)

    def getCutClass(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getCutClass(self)

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerCutEnclosureRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getEolWidth(self)

    def setEolMinLength(self, eol_min_length):
        return _odb_py.dbTechLayerCutEnclosureRule_setEolMinLength(self, eol_min_length)

    def getEolMinLength(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getEolMinLength(self)

    def setFirstOverhang(self, first_overhang):
        return _odb_py.dbTechLayerCutEnclosureRule_setFirstOverhang(self, first_overhang)

    def getFirstOverhang(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getFirstOverhang(self)

    def setSecondOverhang(self, second_overhang):
        return _odb_py.dbTechLayerCutEnclosureRule_setSecondOverhang(self, second_overhang)

    def getSecondOverhang(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getSecondOverhang(self)

    def setSpacing(self, spacing):
        return _odb_py.dbTechLayerCutEnclosureRule_setSpacing(self, spacing)

    def getSpacing(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getSpacing(self)

    def setExtension(self, extension):
        return _odb_py.dbTechLayerCutEnclosureRule_setExtension(self, extension)

    def getExtension(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getExtension(self)

    def setForwardExtension(self, forward_extension):
        return _odb_py.dbTechLayerCutEnclosureRule_setForwardExtension(self, forward_extension)

    def getForwardExtension(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getForwardExtension(self)

    def setBackwardExtension(self, backward_extension):
        return _odb_py.dbTechLayerCutEnclosureRule_setBackwardExtension(self, backward_extension)

    def getBackwardExtension(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getBackwardExtension(self)

    def setMinWidth(self, min_width):
        return _odb_py.dbTechLayerCutEnclosureRule_setMinWidth(self, min_width)

    def getMinWidth(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getMinWidth(self)

    def setCutWithin(self, cut_within):
        return _odb_py.dbTechLayerCutEnclosureRule_setCutWithin(self, cut_within)

    def getCutWithin(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getCutWithin(self)

    def setMinLength(self, min_length):
        return _odb_py.dbTechLayerCutEnclosureRule_setMinLength(self, min_length)

    def getMinLength(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getMinLength(self)

    def setParLength(self, par_length):
        return _odb_py.dbTechLayerCutEnclosureRule_setParLength(self, par_length)

    def getParLength(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getParLength(self)

    def setSecondParLength(self, second_par_length):
        return _odb_py.dbTechLayerCutEnclosureRule_setSecondParLength(self, second_par_length)

    def getSecondParLength(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getSecondParLength(self)

    def setParWithin(self, par_within):
        return _odb_py.dbTechLayerCutEnclosureRule_setParWithin(self, par_within)

    def getParWithin(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getParWithin(self)

    def setSecondParWithin(self, second_par_within):
        return _odb_py.dbTechLayerCutEnclosureRule_setSecondParWithin(self, second_par_within)

    def getSecondParWithin(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getSecondParWithin(self)

    def setBelowEnclosure(self, below_enclosure):
        return _odb_py.dbTechLayerCutEnclosureRule_setBelowEnclosure(self, below_enclosure)

    def getBelowEnclosure(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getBelowEnclosure(self)

    def setNumCorners(self, num_corners):
        return _odb_py.dbTechLayerCutEnclosureRule_setNumCorners(self, num_corners)

    def getNumCorners(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getNumCorners(self)

    def setCutClassValid(self, cut_class_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setCutClassValid(self, cut_class_valid)

    def isCutClassValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isCutClassValid(self)

    def setAbove(self, above):
        return _odb_py.dbTechLayerCutEnclosureRule_setAbove(self, above)

    def isAbove(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isAbove(self)

    def setBelow(self, below):
        return _odb_py.dbTechLayerCutEnclosureRule_setBelow(self, below)

    def isBelow(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isBelow(self)

    def setEolMinLengthValid(self, eol_min_length_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setEolMinLengthValid(self, eol_min_length_valid)

    def isEolMinLengthValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isEolMinLengthValid(self)

    def setEolOnly(self, eol_only):
        return _odb_py.dbTechLayerCutEnclosureRule_setEolOnly(self, eol_only)

    def isEolOnly(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isEolOnly(self)

    def setShortEdgeOnly(self, short_edge_only):
        return _odb_py.dbTechLayerCutEnclosureRule_setShortEdgeOnly(self, short_edge_only)

    def isShortEdgeOnly(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isShortEdgeOnly(self)

    def setSideSpacingValid(self, side_spacing_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setSideSpacingValid(self, side_spacing_valid)

    def isSideSpacingValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isSideSpacingValid(self)

    def setEndSpacingValid(self, end_spacing_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setEndSpacingValid(self, end_spacing_valid)

    def isEndSpacingValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isEndSpacingValid(self)

    def setOffCenterLine(self, off_center_line):
        return _odb_py.dbTechLayerCutEnclosureRule_setOffCenterLine(self, off_center_line)

    def isOffCenterLine(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isOffCenterLine(self)

    def setWidthValid(self, width_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setWidthValid(self, width_valid)

    def isWidthValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isWidthValid(self)

    def setIncludeAbutted(self, include_abutted):
        return _odb_py.dbTechLayerCutEnclosureRule_setIncludeAbutted(self, include_abutted)

    def isIncludeAbutted(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isIncludeAbutted(self)

    def setExceptExtraCut(self, except_extra_cut):
        return _odb_py.dbTechLayerCutEnclosureRule_setExceptExtraCut(self, except_extra_cut)

    def isExceptExtraCut(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isExceptExtraCut(self)

    def setPrl(self, prl):
        return _odb_py.dbTechLayerCutEnclosureRule_setPrl(self, prl)

    def isPrl(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isPrl(self)

    def setNoSharedEdge(self, no_shared_edge):
        return _odb_py.dbTechLayerCutEnclosureRule_setNoSharedEdge(self, no_shared_edge)

    def isNoSharedEdge(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isNoSharedEdge(self)

    def setLengthValid(self, length_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setLengthValid(self, length_valid)

    def isLengthValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isLengthValid(self)

    def setExtraCutValid(self, extra_cut_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setExtraCutValid(self, extra_cut_valid)

    def isExtraCutValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isExtraCutValid(self)

    def setExtraOnly(self, extra_only):
        return _odb_py.dbTechLayerCutEnclosureRule_setExtraOnly(self, extra_only)

    def isExtraOnly(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isExtraOnly(self)

    def setRedundantCutValid(self, redundant_cut_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setRedundantCutValid(self, redundant_cut_valid)

    def isRedundantCutValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isRedundantCutValid(self)

    def setParallelValid(self, parallel_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setParallelValid(self, parallel_valid)

    def isParallelValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isParallelValid(self)

    def setSecondParallelValid(self, second_parallel_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setSecondParallelValid(self, second_parallel_valid)

    def isSecondParallelValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isSecondParallelValid(self)

    def setSecondParWithinValid(self, second_par_within_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setSecondParWithinValid(self, second_par_within_valid)

    def isSecondParWithinValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isSecondParWithinValid(self)

    def setBelowEnclosureValid(self, below_enclosure_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setBelowEnclosureValid(self, below_enclosure_valid)

    def isBelowEnclosureValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isBelowEnclosureValid(self)

    def setConcaveCornersValid(self, concave_corners_valid):
        return _odb_py.dbTechLayerCutEnclosureRule_setConcaveCornersValid(self, concave_corners_valid)

    def isConcaveCornersValid(self):
        return _odb_py.dbTechLayerCutEnclosureRule_isConcaveCornersValid(self)

    def setType(self, type):
        return _odb_py.dbTechLayerCutEnclosureRule_setType(self, type)

    def getType(self):
        return _odb_py.dbTechLayerCutEnclosureRule_getType(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerCutEnclosureRule_create(layer)

    @staticmethod
    def getTechLayerCutEnclosureRule(inly, dbid):
        return _odb_py.dbTechLayerCutEnclosureRule_getTechLayerCutEnclosureRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerCutEnclosureRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerCutEnclosureRule_swiginit(self, _odb_py.new_dbTechLayerCutEnclosureRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerCutEnclosureRule

# Register dbTechLayerCutEnclosureRule in _odb_py:
_odb_py.dbTechLayerCutEnclosureRule_swigregister(dbTechLayerCutEnclosureRule)

def dbTechLayerCutEnclosureRule_create(layer):
    return _odb_py.dbTechLayerCutEnclosureRule_create(layer)

def dbTechLayerCutEnclosureRule_getTechLayerCutEnclosureRule(inly, dbid):
    return _odb_py.dbTechLayerCutEnclosureRule_getTechLayerCutEnclosureRule(inly, dbid)

def dbTechLayerCutEnclosureRule_destroy(rule):
    return _odb_py.dbTechLayerCutEnclosureRule_destroy(rule)

class dbTechLayerCutSpacingRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NONE = _odb_py.dbTechLayerCutSpacingRule_NONE
    MAXXY = _odb_py.dbTechLayerCutSpacingRule_MAXXY
    SAMEMASK = _odb_py.dbTechLayerCutSpacingRule_SAMEMASK
    LAYER = _odb_py.dbTechLayerCutSpacingRule_LAYER
    ADJACENTCUTS = _odb_py.dbTechLayerCutSpacingRule_ADJACENTCUTS
    PARALLELOVERLAP = _odb_py.dbTechLayerCutSpacingRule_PARALLELOVERLAP
    PARALLELWITHIN = _odb_py.dbTechLayerCutSpacingRule_PARALLELWITHIN
    SAMEMETALSHAREDEDGE = _odb_py.dbTechLayerCutSpacingRule_SAMEMETALSHAREDEDGE
    AREA = _odb_py.dbTechLayerCutSpacingRule_AREA

    def setCutSpacing(self, cut_spacing):
        return _odb_py.dbTechLayerCutSpacingRule_setCutSpacing(self, cut_spacing)

    def getCutSpacing(self):
        return _odb_py.dbTechLayerCutSpacingRule_getCutSpacing(self)

    def setSecondLayer(self, second_layer):
        return _odb_py.dbTechLayerCutSpacingRule_setSecondLayer(self, second_layer)

    def setOrthogonalSpacing(self, orthogonal_spacing):
        return _odb_py.dbTechLayerCutSpacingRule_setOrthogonalSpacing(self, orthogonal_spacing)

    def getOrthogonalSpacing(self):
        return _odb_py.dbTechLayerCutSpacingRule_getOrthogonalSpacing(self)

    def setWidth(self, width):
        return _odb_py.dbTechLayerCutSpacingRule_setWidth(self, width)

    def getWidth(self):
        return _odb_py.dbTechLayerCutSpacingRule_getWidth(self)

    def setEnclosure(self, enclosure):
        return _odb_py.dbTechLayerCutSpacingRule_setEnclosure(self, enclosure)

    def getEnclosure(self):
        return _odb_py.dbTechLayerCutSpacingRule_getEnclosure(self)

    def setEdgeLength(self, edge_length):
        return _odb_py.dbTechLayerCutSpacingRule_setEdgeLength(self, edge_length)

    def getEdgeLength(self):
        return _odb_py.dbTechLayerCutSpacingRule_getEdgeLength(self)

    def setParWithin(self, par_within):
        return _odb_py.dbTechLayerCutSpacingRule_setParWithin(self, par_within)

    def getParWithin(self):
        return _odb_py.dbTechLayerCutSpacingRule_getParWithin(self)

    def setParEnclosure(self, par_enclosure):
        return _odb_py.dbTechLayerCutSpacingRule_setParEnclosure(self, par_enclosure)

    def getParEnclosure(self):
        return _odb_py.dbTechLayerCutSpacingRule_getParEnclosure(self)

    def setEdgeEnclosure(self, edge_enclosure):
        return _odb_py.dbTechLayerCutSpacingRule_setEdgeEnclosure(self, edge_enclosure)

    def getEdgeEnclosure(self):
        return _odb_py.dbTechLayerCutSpacingRule_getEdgeEnclosure(self)

    def setAdjEnclosure(self, adj_enclosure):
        return _odb_py.dbTechLayerCutSpacingRule_setAdjEnclosure(self, adj_enclosure)

    def getAdjEnclosure(self):
        return _odb_py.dbTechLayerCutSpacingRule_getAdjEnclosure(self)

    def setAboveEnclosure(self, above_enclosure):
        return _odb_py.dbTechLayerCutSpacingRule_setAboveEnclosure(self, above_enclosure)

    def getAboveEnclosure(self):
        return _odb_py.dbTechLayerCutSpacingRule_getAboveEnclosure(self)

    def setAboveWidth(self, above_width):
        return _odb_py.dbTechLayerCutSpacingRule_setAboveWidth(self, above_width)

    def getAboveWidth(self):
        return _odb_py.dbTechLayerCutSpacingRule_getAboveWidth(self)

    def setMinLength(self, min_length):
        return _odb_py.dbTechLayerCutSpacingRule_setMinLength(self, min_length)

    def getMinLength(self):
        return _odb_py.dbTechLayerCutSpacingRule_getMinLength(self)

    def setExtension(self, extension):
        return _odb_py.dbTechLayerCutSpacingRule_setExtension(self, extension)

    def getExtension(self):
        return _odb_py.dbTechLayerCutSpacingRule_getExtension(self)

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerCutSpacingRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerCutSpacingRule_getEolWidth(self)

    def setNumCuts(self, num_cuts):
        return _odb_py.dbTechLayerCutSpacingRule_setNumCuts(self, num_cuts)

    def getNumCuts(self):
        return _odb_py.dbTechLayerCutSpacingRule_getNumCuts(self)

    def setWithin(self, within):
        return _odb_py.dbTechLayerCutSpacingRule_setWithin(self, within)

    def getWithin(self):
        return _odb_py.dbTechLayerCutSpacingRule_getWithin(self)

    def setSecondWithin(self, second_within):
        return _odb_py.dbTechLayerCutSpacingRule_setSecondWithin(self, second_within)

    def getSecondWithin(self):
        return _odb_py.dbTechLayerCutSpacingRule_getSecondWithin(self)

    def setCutClass(self, cut_class):
        return _odb_py.dbTechLayerCutSpacingRule_setCutClass(self, cut_class)

    def setTwoCuts(self, two_cuts):
        return _odb_py.dbTechLayerCutSpacingRule_setTwoCuts(self, two_cuts)

    def getTwoCuts(self):
        return _odb_py.dbTechLayerCutSpacingRule_getTwoCuts(self)

    def setPrl(self, prl):
        return _odb_py.dbTechLayerCutSpacingRule_setPrl(self, prl)

    def getPrl(self):
        return _odb_py.dbTechLayerCutSpacingRule_getPrl(self)

    def setParLength(self, par_length):
        return _odb_py.dbTechLayerCutSpacingRule_setParLength(self, par_length)

    def getParLength(self):
        return _odb_py.dbTechLayerCutSpacingRule_getParLength(self)

    def setCutArea(self, cut_area):
        return _odb_py.dbTechLayerCutSpacingRule_setCutArea(self, cut_area)

    def getCutArea(self):
        return _odb_py.dbTechLayerCutSpacingRule_getCutArea(self)

    def setCenterToCenter(self, center_to_center):
        return _odb_py.dbTechLayerCutSpacingRule_setCenterToCenter(self, center_to_center)

    def isCenterToCenter(self):
        return _odb_py.dbTechLayerCutSpacingRule_isCenterToCenter(self)

    def setSameNet(self, same_net):
        return _odb_py.dbTechLayerCutSpacingRule_setSameNet(self, same_net)

    def isSameNet(self):
        return _odb_py.dbTechLayerCutSpacingRule_isSameNet(self)

    def setSameMetal(self, same_metal):
        return _odb_py.dbTechLayerCutSpacingRule_setSameMetal(self, same_metal)

    def isSameMetal(self):
        return _odb_py.dbTechLayerCutSpacingRule_isSameMetal(self)

    def setSameVia(self, same_via):
        return _odb_py.dbTechLayerCutSpacingRule_setSameVia(self, same_via)

    def isSameVia(self):
        return _odb_py.dbTechLayerCutSpacingRule_isSameVia(self)

    def setStack(self, stack):
        return _odb_py.dbTechLayerCutSpacingRule_setStack(self, stack)

    def isStack(self):
        return _odb_py.dbTechLayerCutSpacingRule_isStack(self)

    def setOrthogonalSpacingValid(self, orthogonal_spacing_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setOrthogonalSpacingValid(self, orthogonal_spacing_valid)

    def isOrthogonalSpacingValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isOrthogonalSpacingValid(self)

    def setAboveWidthEnclosureValid(self, above_width_enclosure_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setAboveWidthEnclosureValid(self, above_width_enclosure_valid)

    def isAboveWidthEnclosureValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isAboveWidthEnclosureValid(self)

    def setShortEdgeOnly(self, short_edge_only):
        return _odb_py.dbTechLayerCutSpacingRule_setShortEdgeOnly(self, short_edge_only)

    def isShortEdgeOnly(self):
        return _odb_py.dbTechLayerCutSpacingRule_isShortEdgeOnly(self)

    def setConcaveCornerWidth(self, concave_corner_width):
        return _odb_py.dbTechLayerCutSpacingRule_setConcaveCornerWidth(self, concave_corner_width)

    def isConcaveCornerWidth(self):
        return _odb_py.dbTechLayerCutSpacingRule_isConcaveCornerWidth(self)

    def setConcaveCornerParallel(self, concave_corner_parallel):
        return _odb_py.dbTechLayerCutSpacingRule_setConcaveCornerParallel(self, concave_corner_parallel)

    def isConcaveCornerParallel(self):
        return _odb_py.dbTechLayerCutSpacingRule_isConcaveCornerParallel(self)

    def setConcaveCornerEdgeLength(self, concave_corner_edge_length):
        return _odb_py.dbTechLayerCutSpacingRule_setConcaveCornerEdgeLength(self, concave_corner_edge_length)

    def isConcaveCornerEdgeLength(self):
        return _odb_py.dbTechLayerCutSpacingRule_isConcaveCornerEdgeLength(self)

    def setConcaveCorner(self, concave_corner):
        return _odb_py.dbTechLayerCutSpacingRule_setConcaveCorner(self, concave_corner)

    def isConcaveCorner(self):
        return _odb_py.dbTechLayerCutSpacingRule_isConcaveCorner(self)

    def setExtensionValid(self, extension_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setExtensionValid(self, extension_valid)

    def isExtensionValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExtensionValid(self)

    def setNonEolConvexCorner(self, non_eol_convex_corner):
        return _odb_py.dbTechLayerCutSpacingRule_setNonEolConvexCorner(self, non_eol_convex_corner)

    def isNonEolConvexCorner(self):
        return _odb_py.dbTechLayerCutSpacingRule_isNonEolConvexCorner(self)

    def setEolWidthValid(self, eol_width_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setEolWidthValid(self, eol_width_valid)

    def isEolWidthValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isEolWidthValid(self)

    def setMinLengthValid(self, min_length_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setMinLengthValid(self, min_length_valid)

    def isMinLengthValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isMinLengthValid(self)

    def setAboveWidthValid(self, above_width_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setAboveWidthValid(self, above_width_valid)

    def isAboveWidthValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isAboveWidthValid(self)

    def setMaskOverlap(self, mask_overlap):
        return _odb_py.dbTechLayerCutSpacingRule_setMaskOverlap(self, mask_overlap)

    def isMaskOverlap(self):
        return _odb_py.dbTechLayerCutSpacingRule_isMaskOverlap(self)

    def setWrongDirection(self, wrong_direction):
        return _odb_py.dbTechLayerCutSpacingRule_setWrongDirection(self, wrong_direction)

    def isWrongDirection(self):
        return _odb_py.dbTechLayerCutSpacingRule_isWrongDirection(self)

    def setAdjacentCuts(self, adjacent_cuts):
        return _odb_py.dbTechLayerCutSpacingRule_setAdjacentCuts(self, adjacent_cuts)

    def getAdjacentCuts(self):
        return _odb_py.dbTechLayerCutSpacingRule_getAdjacentCuts(self)

    def setExactAligned(self, exact_aligned):
        return _odb_py.dbTechLayerCutSpacingRule_setExactAligned(self, exact_aligned)

    def isExactAligned(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExactAligned(self)

    def setCutClassToAll(self, cut_class_to_all):
        return _odb_py.dbTechLayerCutSpacingRule_setCutClassToAll(self, cut_class_to_all)

    def isCutClassToAll(self):
        return _odb_py.dbTechLayerCutSpacingRule_isCutClassToAll(self)

    def setNoPrl(self, no_prl):
        return _odb_py.dbTechLayerCutSpacingRule_setNoPrl(self, no_prl)

    def isNoPrl(self):
        return _odb_py.dbTechLayerCutSpacingRule_isNoPrl(self)

    def setSameMask(self, same_mask):
        return _odb_py.dbTechLayerCutSpacingRule_setSameMask(self, same_mask)

    def isSameMask(self):
        return _odb_py.dbTechLayerCutSpacingRule_isSameMask(self)

    def setExceptSamePgnet(self, except_same_pgnet):
        return _odb_py.dbTechLayerCutSpacingRule_setExceptSamePgnet(self, except_same_pgnet)

    def isExceptSamePgnet(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExceptSamePgnet(self)

    def setSideParallelOverlap(self, side_parallel_overlap):
        return _odb_py.dbTechLayerCutSpacingRule_setSideParallelOverlap(self, side_parallel_overlap)

    def isSideParallelOverlap(self):
        return _odb_py.dbTechLayerCutSpacingRule_isSideParallelOverlap(self)

    def setExceptSameNet(self, except_same_net):
        return _odb_py.dbTechLayerCutSpacingRule_setExceptSameNet(self, except_same_net)

    def isExceptSameNet(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExceptSameNet(self)

    def setExceptSameMetal(self, except_same_metal):
        return _odb_py.dbTechLayerCutSpacingRule_setExceptSameMetal(self, except_same_metal)

    def isExceptSameMetal(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExceptSameMetal(self)

    def setExceptSameMetalOverlap(self, except_same_metal_overlap):
        return _odb_py.dbTechLayerCutSpacingRule_setExceptSameMetalOverlap(self, except_same_metal_overlap)

    def isExceptSameMetalOverlap(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExceptSameMetalOverlap(self)

    def setExceptSameVia(self, except_same_via):
        return _odb_py.dbTechLayerCutSpacingRule_setExceptSameVia(self, except_same_via)

    def isExceptSameVia(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExceptSameVia(self)

    def setAbove(self, above):
        return _odb_py.dbTechLayerCutSpacingRule_setAbove(self, above)

    def isAbove(self):
        return _odb_py.dbTechLayerCutSpacingRule_isAbove(self)

    def setExceptTwoEdges(self, except_two_edges):
        return _odb_py.dbTechLayerCutSpacingRule_setExceptTwoEdges(self, except_two_edges)

    def isExceptTwoEdges(self):
        return _odb_py.dbTechLayerCutSpacingRule_isExceptTwoEdges(self)

    def setTwoCutsValid(self, two_cuts_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setTwoCutsValid(self, two_cuts_valid)

    def isTwoCutsValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isTwoCutsValid(self)

    def setSameCut(self, same_cut):
        return _odb_py.dbTechLayerCutSpacingRule_setSameCut(self, same_cut)

    def isSameCut(self):
        return _odb_py.dbTechLayerCutSpacingRule_isSameCut(self)

    def setLongEdgeOnly(self, long_edge_only):
        return _odb_py.dbTechLayerCutSpacingRule_setLongEdgeOnly(self, long_edge_only)

    def isLongEdgeOnly(self):
        return _odb_py.dbTechLayerCutSpacingRule_isLongEdgeOnly(self)

    def setPrlValid(self, prl_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setPrlValid(self, prl_valid)

    def isPrlValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isPrlValid(self)

    def setBelow(self, below):
        return _odb_py.dbTechLayerCutSpacingRule_setBelow(self, below)

    def isBelow(self):
        return _odb_py.dbTechLayerCutSpacingRule_isBelow(self)

    def setParWithinEnclosureValid(self, par_within_enclosure_valid):
        return _odb_py.dbTechLayerCutSpacingRule_setParWithinEnclosureValid(self, par_within_enclosure_valid)

    def isParWithinEnclosureValid(self):
        return _odb_py.dbTechLayerCutSpacingRule_isParWithinEnclosureValid(self)

    def getCutClass(self):
        return _odb_py.dbTechLayerCutSpacingRule_getCutClass(self)

    def getSecondLayer(self):
        return _odb_py.dbTechLayerCutSpacingRule_getSecondLayer(self)

    def getTechLayer(self):
        return _odb_py.dbTechLayerCutSpacingRule_getTechLayer(self)

    def setType(self, _type):
        return _odb_py.dbTechLayerCutSpacingRule_setType(self, _type)

    def getType(self):
        return _odb_py.dbTechLayerCutSpacingRule_getType(self)

    @staticmethod
    def getTechLayerCutSpacingRule(inly, dbid):
        return _odb_py.dbTechLayerCutSpacingRule_getTechLayerCutSpacingRule(inly, dbid)

    @staticmethod
    def create(_layer):
        return _odb_py.dbTechLayerCutSpacingRule_create(_layer)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerCutSpacingRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerCutSpacingRule_swiginit(self, _odb_py.new_dbTechLayerCutSpacingRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerCutSpacingRule

# Register dbTechLayerCutSpacingRule in _odb_py:
_odb_py.dbTechLayerCutSpacingRule_swigregister(dbTechLayerCutSpacingRule)

def dbTechLayerCutSpacingRule_getTechLayerCutSpacingRule(inly, dbid):
    return _odb_py.dbTechLayerCutSpacingRule_getTechLayerCutSpacingRule(inly, dbid)

def dbTechLayerCutSpacingRule_create(_layer):
    return _odb_py.dbTechLayerCutSpacingRule_create(_layer)

def dbTechLayerCutSpacingRule_destroy(rule):
    return _odb_py.dbTechLayerCutSpacingRule_destroy(rule)

class dbTechLayerCutSpacingTableDefRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FIRST = _odb_py.dbTechLayerCutSpacingTableDefRule_FIRST
    SECOND = _odb_py.dbTechLayerCutSpacingTableDefRule_SECOND
    MAX = _odb_py.dbTechLayerCutSpacingTableDefRule_MAX
    MIN = _odb_py.dbTechLayerCutSpacingTableDefRule_MIN

    def setDefault(self, spacing):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setDefault(self, spacing)

    def getDefault(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getDefault(self)

    def setSecondLayer(self, second_layer):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSecondLayer(self, second_layer)

    def setPrl(self, prl):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setPrl(self, prl)

    def getPrl(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getPrl(self)

    def setExtension(self, extension):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setExtension(self, extension)

    def getExtension(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getExtension(self)

    def setDefaultValid(self, default_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setDefaultValid(self, default_valid)

    def isDefaultValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isDefaultValid(self)

    def setSameMask(self, same_mask):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSameMask(self, same_mask)

    def isSameMask(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isSameMask(self)

    def setSameNet(self, same_net):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSameNet(self, same_net)

    def isSameNet(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isSameNet(self)

    def setSameMetal(self, same_metal):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSameMetal(self, same_metal)

    def isSameMetal(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isSameMetal(self)

    def setSameVia(self, same_via):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSameVia(self, same_via)

    def isSameVia(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isSameVia(self)

    def setLayerValid(self, layer_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setLayerValid(self, layer_valid)

    def isLayerValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isLayerValid(self)

    def setNoStack(self, no_stack):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setNoStack(self, no_stack)

    def isNoStack(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isNoStack(self)

    def setNonZeroEnclosure(self, non_zero_enclosure):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setNonZeroEnclosure(self, non_zero_enclosure)

    def isNonZeroEnclosure(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isNonZeroEnclosure(self)

    def setPrlForAlignedCut(self, prl_for_aligned_cut):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setPrlForAlignedCut(self, prl_for_aligned_cut)

    def isPrlForAlignedCut(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isPrlForAlignedCut(self)

    def setCenterToCenterValid(self, center_to_center_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setCenterToCenterValid(self, center_to_center_valid)

    def isCenterToCenterValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isCenterToCenterValid(self)

    def setCenterAndEdgeValid(self, center_and_edge_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setCenterAndEdgeValid(self, center_and_edge_valid)

    def isCenterAndEdgeValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isCenterAndEdgeValid(self)

    def setNoPrl(self, no_prl):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setNoPrl(self, no_prl)

    def isNoPrl(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isNoPrl(self)

    def setPrlValid(self, prl_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setPrlValid(self, prl_valid)

    def isPrlValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isPrlValid(self)

    def setMaxXY(self, max_x_y):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setMaxXY(self, max_x_y)

    def isMaxXY(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isMaxXY(self)

    def setEndExtensionValid(self, end_extension_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setEndExtensionValid(self, end_extension_valid)

    def isEndExtensionValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isEndExtensionValid(self)

    def setSideExtensionValid(self, side_extension_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSideExtensionValid(self, side_extension_valid)

    def isSideExtensionValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isSideExtensionValid(self)

    def setExactAlignedSpacingValid(self, exact_aligned_spacing_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setExactAlignedSpacingValid(self, exact_aligned_spacing_valid)

    def isExactAlignedSpacingValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isExactAlignedSpacingValid(self)

    def setHorizontal(self, horizontal):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setHorizontal(self, horizontal)

    def isHorizontal(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isHorizontal(self)

    def setPrlHorizontal(self, prl_horizontal):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setPrlHorizontal(self, prl_horizontal)

    def isPrlHorizontal(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isPrlHorizontal(self)

    def setVertical(self, vertical):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setVertical(self, vertical)

    def isVertical(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isVertical(self)

    def setPrlVertical(self, prl_vertical):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setPrlVertical(self, prl_vertical)

    def isPrlVertical(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isPrlVertical(self)

    def setNonOppositeEnclosureSpacingValid(self, non_opposite_enclosure_spacing_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setNonOppositeEnclosureSpacingValid(self, non_opposite_enclosure_spacing_valid)

    def isNonOppositeEnclosureSpacingValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isNonOppositeEnclosureSpacingValid(self)

    def setOppositeEnclosureResizeSpacingValid(self, opposite_enclosure_resize_spacing_valid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setOppositeEnclosureResizeSpacingValid(self, opposite_enclosure_resize_spacing_valid)

    def isOppositeEnclosureResizeSpacingValid(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isOppositeEnclosureResizeSpacingValid(self)

    def addPrlForAlignedCutEntry(self, _from, to):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addPrlForAlignedCutEntry(self, _from, to)

    def addCenterToCenterEntry(self, _from, to):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addCenterToCenterEntry(self, _from, to)

    def addCenterAndEdgeEntry(self, _from, to):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addCenterAndEdgeEntry(self, _from, to)

    def addPrlEntry(self, _from, to, ccPrl):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addPrlEntry(self, _from, to, ccPrl)

    def addEndExtensionEntry(self, cls, ext):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addEndExtensionEntry(self, cls, ext)

    def addSideExtensionEntry(self, cls, ext):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addSideExtensionEntry(self, cls, ext)

    def addExactElignedEntry(self, cls, spacing):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addExactElignedEntry(self, cls, spacing)

    def addNonOppEncSpacingEntry(self, cls, spacing):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addNonOppEncSpacingEntry(self, cls, spacing)

    def addOppEncSpacingEntry(self, cls, rsz1, rsz2, spacing):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_addOppEncSpacingEntry(self, cls, rsz1, rsz2, spacing)

    def getSecondLayer(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getSecondLayer(self)

    def isCenterToCenter(self, cutClass1, cutClass2):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isCenterToCenter(self, cutClass1, cutClass2)

    def isCenterAndEdge(self, cutClass1, cutClass2):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isCenterAndEdge(self, cutClass1, cutClass2)

    def isPrlForAlignedCutClasses(self, cutClass1, cutClass2):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_isPrlForAlignedCutClasses(self, cutClass1, cutClass2)

    def getPrlEntry(self, cutClass1, cutClass2):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getPrlEntry(self, cutClass1, cutClass2)

    def setSpacingTable(self, table, row_map, col_map):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_setSpacingTable(self, table, row_map, col_map)

    def getSpacingTable(self, table, row_map, col_map):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getSpacingTable(self, table, row_map, col_map)

    def getExactAlignedSpacing(self, cutClass):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getExactAlignedSpacing(self, cutClass)

    def getMaxSpacing(self, *args):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getMaxSpacing(self, *args)

    def getSpacing(self, *args):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getSpacing(self, *args)

    def getTechLayer(self):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getTechLayer(self)

    @staticmethod
    def create(parent):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_create(parent)

    @staticmethod
    def getTechLayerCutSpacingTableDefSubRule(parent, dbid):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_getTechLayerCutSpacingTableDefSubRule(parent, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerCutSpacingTableDefRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerCutSpacingTableDefRule_swiginit(self, _odb_py.new_dbTechLayerCutSpacingTableDefRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerCutSpacingTableDefRule

# Register dbTechLayerCutSpacingTableDefRule in _odb_py:
_odb_py.dbTechLayerCutSpacingTableDefRule_swigregister(dbTechLayerCutSpacingTableDefRule)

def dbTechLayerCutSpacingTableDefRule_create(parent):
    return _odb_py.dbTechLayerCutSpacingTableDefRule_create(parent)

def dbTechLayerCutSpacingTableDefRule_getTechLayerCutSpacingTableDefSubRule(parent, dbid):
    return _odb_py.dbTechLayerCutSpacingTableDefRule_getTechLayerCutSpacingTableDefSubRule(parent, dbid)

def dbTechLayerCutSpacingTableDefRule_destroy(rule):
    return _odb_py.dbTechLayerCutSpacingTableDefRule_destroy(rule)

class dbTechLayerCutSpacingTableOrthRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getSpacingTable(self, tbl):
        return _odb_py.dbTechLayerCutSpacingTableOrthRule_getSpacingTable(self, tbl)

    def setSpacingTable(self, tbl):
        return _odb_py.dbTechLayerCutSpacingTableOrthRule_setSpacingTable(self, tbl)

    @staticmethod
    def create(parent):
        return _odb_py.dbTechLayerCutSpacingTableOrthRule_create(parent)

    @staticmethod
    def getTechLayerCutSpacingTableOrthSubRule(parent, dbid):
        return _odb_py.dbTechLayerCutSpacingTableOrthRule_getTechLayerCutSpacingTableOrthSubRule(parent, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerCutSpacingTableOrthRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerCutSpacingTableOrthRule_swiginit(self, _odb_py.new_dbTechLayerCutSpacingTableOrthRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerCutSpacingTableOrthRule

# Register dbTechLayerCutSpacingTableOrthRule in _odb_py:
_odb_py.dbTechLayerCutSpacingTableOrthRule_swigregister(dbTechLayerCutSpacingTableOrthRule)

def dbTechLayerCutSpacingTableOrthRule_create(parent):
    return _odb_py.dbTechLayerCutSpacingTableOrthRule_create(parent)

def dbTechLayerCutSpacingTableOrthRule_getTechLayerCutSpacingTableOrthSubRule(parent, dbid):
    return _odb_py.dbTechLayerCutSpacingTableOrthRule_getTechLayerCutSpacingTableOrthSubRule(parent, dbid)

def dbTechLayerCutSpacingTableOrthRule_destroy(rule):
    return _odb_py.dbTechLayerCutSpacingTableOrthRule_destroy(rule)

class dbTechLayerEolExtensionRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setSpacing(self, spacing):
        return _odb_py.dbTechLayerEolExtensionRule_setSpacing(self, spacing)

    def getSpacing(self):
        return _odb_py.dbTechLayerEolExtensionRule_getSpacing(self)

    def getExtensionTable(self, tbl):
        return _odb_py.dbTechLayerEolExtensionRule_getExtensionTable(self, tbl)

    def setParallelOnly(self, parallel_only):
        return _odb_py.dbTechLayerEolExtensionRule_setParallelOnly(self, parallel_only)

    def isParallelOnly(self):
        return _odb_py.dbTechLayerEolExtensionRule_isParallelOnly(self)

    def addEntry(self, eol, ext):
        return _odb_py.dbTechLayerEolExtensionRule_addEntry(self, eol, ext)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerEolExtensionRule_create(layer)

    @staticmethod
    def getTechLayerEolExtensionRule(inly, dbid):
        return _odb_py.dbTechLayerEolExtensionRule_getTechLayerEolExtensionRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerEolExtensionRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerEolExtensionRule_swiginit(self, _odb_py.new_dbTechLayerEolExtensionRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerEolExtensionRule

# Register dbTechLayerEolExtensionRule in _odb_py:
_odb_py.dbTechLayerEolExtensionRule_swigregister(dbTechLayerEolExtensionRule)

def dbTechLayerEolExtensionRule_create(layer):
    return _odb_py.dbTechLayerEolExtensionRule_create(layer)

def dbTechLayerEolExtensionRule_getTechLayerEolExtensionRule(inly, dbid):
    return _odb_py.dbTechLayerEolExtensionRule_getTechLayerEolExtensionRule(inly, dbid)

def dbTechLayerEolExtensionRule_destroy(rule):
    return _odb_py.dbTechLayerEolExtensionRule_destroy(rule)

class dbTechLayerEolKeepOutRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerEolKeepOutRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getEolWidth(self)

    def setBackwardExt(self, backward_ext):
        return _odb_py.dbTechLayerEolKeepOutRule_setBackwardExt(self, backward_ext)

    def getBackwardExt(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getBackwardExt(self)

    def setForwardExt(self, forward_ext):
        return _odb_py.dbTechLayerEolKeepOutRule_setForwardExt(self, forward_ext)

    def getForwardExt(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getForwardExt(self)

    def setSideExt(self, side_ext):
        return _odb_py.dbTechLayerEolKeepOutRule_setSideExt(self, side_ext)

    def getSideExt(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getSideExt(self)

    def setWithinLow(self, within_low):
        return _odb_py.dbTechLayerEolKeepOutRule_setWithinLow(self, within_low)

    def getWithinLow(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getWithinLow(self)

    def setWithinHigh(self, within_high):
        return _odb_py.dbTechLayerEolKeepOutRule_setWithinHigh(self, within_high)

    def getWithinHigh(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getWithinHigh(self)

    def setClassName(self, class_name):
        return _odb_py.dbTechLayerEolKeepOutRule_setClassName(self, class_name)

    def getClassName(self):
        return _odb_py.dbTechLayerEolKeepOutRule_getClassName(self)

    def setClassValid(self, class_valid):
        return _odb_py.dbTechLayerEolKeepOutRule_setClassValid(self, class_valid)

    def isClassValid(self):
        return _odb_py.dbTechLayerEolKeepOutRule_isClassValid(self)

    def setCornerOnly(self, corner_only):
        return _odb_py.dbTechLayerEolKeepOutRule_setCornerOnly(self, corner_only)

    def isCornerOnly(self):
        return _odb_py.dbTechLayerEolKeepOutRule_isCornerOnly(self)

    def setExceptWithin(self, except_within):
        return _odb_py.dbTechLayerEolKeepOutRule_setExceptWithin(self, except_within)

    def isExceptWithin(self):
        return _odb_py.dbTechLayerEolKeepOutRule_isExceptWithin(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerEolKeepOutRule_create(layer)

    @staticmethod
    def getTechLayerEolKeepOutRule(inly, dbid):
        return _odb_py.dbTechLayerEolKeepOutRule_getTechLayerEolKeepOutRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerEolKeepOutRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerEolKeepOutRule_swiginit(self, _odb_py.new_dbTechLayerEolKeepOutRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerEolKeepOutRule

# Register dbTechLayerEolKeepOutRule in _odb_py:
_odb_py.dbTechLayerEolKeepOutRule_swigregister(dbTechLayerEolKeepOutRule)

def dbTechLayerEolKeepOutRule_create(layer):
    return _odb_py.dbTechLayerEolKeepOutRule_create(layer)

def dbTechLayerEolKeepOutRule_getTechLayerEolKeepOutRule(inly, dbid):
    return _odb_py.dbTechLayerEolKeepOutRule_getTechLayerEolKeepOutRule(inly, dbid)

def dbTechLayerEolKeepOutRule_destroy(rule):
    return _odb_py.dbTechLayerEolKeepOutRule_destroy(rule)

class dbTechLayerForbiddenSpacingRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setForbiddenSpacing(self, forbidden_spacing):
        return _odb_py.dbTechLayerForbiddenSpacingRule_setForbiddenSpacing(self, forbidden_spacing)

    def getForbiddenSpacing(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_getForbiddenSpacing(self)

    def setWidth(self, width):
        return _odb_py.dbTechLayerForbiddenSpacingRule_setWidth(self, width)

    def getWidth(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_getWidth(self)

    def setWithin(self, within):
        return _odb_py.dbTechLayerForbiddenSpacingRule_setWithin(self, within)

    def getWithin(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_getWithin(self)

    def setPrl(self, prl):
        return _odb_py.dbTechLayerForbiddenSpacingRule_setPrl(self, prl)

    def getPrl(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_getPrl(self)

    def setTwoEdges(self, two_edges):
        return _odb_py.dbTechLayerForbiddenSpacingRule_setTwoEdges(self, two_edges)

    def getTwoEdges(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_getTwoEdges(self)

    def hasWidth(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_hasWidth(self)

    def hasWithin(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_hasWithin(self)

    def hasPrl(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_hasPrl(self)

    def hasTwoEdges(self):
        return _odb_py.dbTechLayerForbiddenSpacingRule_hasTwoEdges(self)

    @staticmethod
    def create(_layer):
        return _odb_py.dbTechLayerForbiddenSpacingRule_create(_layer)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerForbiddenSpacingRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerForbiddenSpacingRule_swiginit(self, _odb_py.new_dbTechLayerForbiddenSpacingRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerForbiddenSpacingRule

# Register dbTechLayerForbiddenSpacingRule in _odb_py:
_odb_py.dbTechLayerForbiddenSpacingRule_swigregister(dbTechLayerForbiddenSpacingRule)

def dbTechLayerForbiddenSpacingRule_create(_layer):
    return _odb_py.dbTechLayerForbiddenSpacingRule_create(_layer)

def dbTechLayerForbiddenSpacingRule_destroy(rule):
    return _odb_py.dbTechLayerForbiddenSpacingRule_destroy(rule)

class dbTechLayerKeepOutZoneRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setFirstCutClass(self, first_cut_class):
        return _odb_py.dbTechLayerKeepOutZoneRule_setFirstCutClass(self, first_cut_class)

    def getFirstCutClass(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getFirstCutClass(self)

    def setSecondCutClass(self, second_cut_class):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSecondCutClass(self, second_cut_class)

    def getSecondCutClass(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getSecondCutClass(self)

    def setAlignedSpacing(self, aligned_spacing):
        return _odb_py.dbTechLayerKeepOutZoneRule_setAlignedSpacing(self, aligned_spacing)

    def getAlignedSpacing(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getAlignedSpacing(self)

    def setSideExtension(self, side_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSideExtension(self, side_extension)

    def getSideExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getSideExtension(self)

    def setForwardExtension(self, forward_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setForwardExtension(self, forward_extension)

    def getForwardExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getForwardExtension(self)

    def setEndSideExtension(self, end_side_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setEndSideExtension(self, end_side_extension)

    def getEndSideExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getEndSideExtension(self)

    def setEndForwardExtension(self, end_forward_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setEndForwardExtension(self, end_forward_extension)

    def getEndForwardExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getEndForwardExtension(self)

    def setSideSideExtension(self, side_side_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSideSideExtension(self, side_side_extension)

    def getSideSideExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getSideSideExtension(self)

    def setSideForwardExtension(self, side_forward_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSideForwardExtension(self, side_forward_extension)

    def getSideForwardExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getSideForwardExtension(self)

    def setSpiralExtension(self, spiral_extension):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSpiralExtension(self, spiral_extension)

    def getSpiralExtension(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_getSpiralExtension(self)

    def setSameMask(self, same_mask):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSameMask(self, same_mask)

    def isSameMask(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_isSameMask(self)

    def setSameMetal(self, same_metal):
        return _odb_py.dbTechLayerKeepOutZoneRule_setSameMetal(self, same_metal)

    def isSameMetal(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_isSameMetal(self)

    def setDiffMetal(self, diff_metal):
        return _odb_py.dbTechLayerKeepOutZoneRule_setDiffMetal(self, diff_metal)

    def isDiffMetal(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_isDiffMetal(self)

    def setExceptAlignedSide(self, except_aligned_side):
        return _odb_py.dbTechLayerKeepOutZoneRule_setExceptAlignedSide(self, except_aligned_side)

    def isExceptAlignedSide(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_isExceptAlignedSide(self)

    def setExceptAlignedEnd(self, except_aligned_end):
        return _odb_py.dbTechLayerKeepOutZoneRule_setExceptAlignedEnd(self, except_aligned_end)

    def isExceptAlignedEnd(self):
        return _odb_py.dbTechLayerKeepOutZoneRule_isExceptAlignedEnd(self)

    @staticmethod
    def create(_layer):
        return _odb_py.dbTechLayerKeepOutZoneRule_create(_layer)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerKeepOutZoneRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerKeepOutZoneRule_swiginit(self, _odb_py.new_dbTechLayerKeepOutZoneRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerKeepOutZoneRule

# Register dbTechLayerKeepOutZoneRule in _odb_py:
_odb_py.dbTechLayerKeepOutZoneRule_swigregister(dbTechLayerKeepOutZoneRule)

def dbTechLayerKeepOutZoneRule_create(_layer):
    return _odb_py.dbTechLayerKeepOutZoneRule_create(_layer)

def dbTechLayerKeepOutZoneRule_destroy(rule):
    return _odb_py.dbTechLayerKeepOutZoneRule_destroy(rule)

class dbTechLayerMinCutRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setNumCuts(self, num_cuts):
        return _odb_py.dbTechLayerMinCutRule_setNumCuts(self, num_cuts)

    def getNumCuts(self):
        return _odb_py.dbTechLayerMinCutRule_getNumCuts(self)

    def getCutClassCutsMap(self):
        return _odb_py.dbTechLayerMinCutRule_getCutClassCutsMap(self)

    def setWidth(self, width):
        return _odb_py.dbTechLayerMinCutRule_setWidth(self, width)

    def getWidth(self):
        return _odb_py.dbTechLayerMinCutRule_getWidth(self)

    def setWithinCutDist(self, within_cut_dist):
        return _odb_py.dbTechLayerMinCutRule_setWithinCutDist(self, within_cut_dist)

    def getWithinCutDist(self):
        return _odb_py.dbTechLayerMinCutRule_getWithinCutDist(self)

    def setLength(self, length):
        return _odb_py.dbTechLayerMinCutRule_setLength(self, length)

    def getLength(self):
        return _odb_py.dbTechLayerMinCutRule_getLength(self)

    def setLengthWithinDist(self, length_within_dist):
        return _odb_py.dbTechLayerMinCutRule_setLengthWithinDist(self, length_within_dist)

    def getLengthWithinDist(self):
        return _odb_py.dbTechLayerMinCutRule_getLengthWithinDist(self)

    def setArea(self, area):
        return _odb_py.dbTechLayerMinCutRule_setArea(self, area)

    def getArea(self):
        return _odb_py.dbTechLayerMinCutRule_getArea(self)

    def setAreaWithinDist(self, area_within_dist):
        return _odb_py.dbTechLayerMinCutRule_setAreaWithinDist(self, area_within_dist)

    def getAreaWithinDist(self):
        return _odb_py.dbTechLayerMinCutRule_getAreaWithinDist(self)

    def setPerCutClass(self, per_cut_class):
        return _odb_py.dbTechLayerMinCutRule_setPerCutClass(self, per_cut_class)

    def isPerCutClass(self):
        return _odb_py.dbTechLayerMinCutRule_isPerCutClass(self)

    def setWithinCutDistValid(self, within_cut_dist_valid):
        return _odb_py.dbTechLayerMinCutRule_setWithinCutDistValid(self, within_cut_dist_valid)

    def isWithinCutDistValid(self):
        return _odb_py.dbTechLayerMinCutRule_isWithinCutDistValid(self)

    def setFromAbove(self, from_above):
        return _odb_py.dbTechLayerMinCutRule_setFromAbove(self, from_above)

    def isFromAbove(self):
        return _odb_py.dbTechLayerMinCutRule_isFromAbove(self)

    def setFromBelow(self, from_below):
        return _odb_py.dbTechLayerMinCutRule_setFromBelow(self, from_below)

    def isFromBelow(self):
        return _odb_py.dbTechLayerMinCutRule_isFromBelow(self)

    def setLengthValid(self, length_valid):
        return _odb_py.dbTechLayerMinCutRule_setLengthValid(self, length_valid)

    def isLengthValid(self):
        return _odb_py.dbTechLayerMinCutRule_isLengthValid(self)

    def setAreaValid(self, area_valid):
        return _odb_py.dbTechLayerMinCutRule_setAreaValid(self, area_valid)

    def isAreaValid(self):
        return _odb_py.dbTechLayerMinCutRule_isAreaValid(self)

    def setAreaWithinDistValid(self, area_within_dist_valid):
        return _odb_py.dbTechLayerMinCutRule_setAreaWithinDistValid(self, area_within_dist_valid)

    def isAreaWithinDistValid(self):
        return _odb_py.dbTechLayerMinCutRule_isAreaWithinDistValid(self)

    def setSameMetalOverlap(self, same_metal_overlap):
        return _odb_py.dbTechLayerMinCutRule_setSameMetalOverlap(self, same_metal_overlap)

    def isSameMetalOverlap(self):
        return _odb_py.dbTechLayerMinCutRule_isSameMetalOverlap(self)

    def setFullyEnclosed(self, fully_enclosed):
        return _odb_py.dbTechLayerMinCutRule_setFullyEnclosed(self, fully_enclosed)

    def isFullyEnclosed(self):
        return _odb_py.dbTechLayerMinCutRule_isFullyEnclosed(self)

    def setCutsPerCutClass(self, cut_class, num_cuts):
        return _odb_py.dbTechLayerMinCutRule_setCutsPerCutClass(self, cut_class, num_cuts)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerMinCutRule_create(layer)

    @staticmethod
    def getTechLayerMinCutRule(inly, dbid):
        return _odb_py.dbTechLayerMinCutRule_getTechLayerMinCutRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerMinCutRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerMinCutRule_swiginit(self, _odb_py.new_dbTechLayerMinCutRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerMinCutRule

# Register dbTechLayerMinCutRule in _odb_py:
_odb_py.dbTechLayerMinCutRule_swigregister(dbTechLayerMinCutRule)

def dbTechLayerMinCutRule_create(layer):
    return _odb_py.dbTechLayerMinCutRule_create(layer)

def dbTechLayerMinCutRule_getTechLayerMinCutRule(inly, dbid):
    return _odb_py.dbTechLayerMinCutRule_getTechLayerMinCutRule(inly, dbid)

def dbTechLayerMinCutRule_destroy(rule):
    return _odb_py.dbTechLayerMinCutRule_destroy(rule)

class dbTechLayerMinStepRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMinStepLength(self, min_step_length):
        return _odb_py.dbTechLayerMinStepRule_setMinStepLength(self, min_step_length)

    def getMinStepLength(self):
        return _odb_py.dbTechLayerMinStepRule_getMinStepLength(self)

    def setMaxEdges(self, max_edges):
        return _odb_py.dbTechLayerMinStepRule_setMaxEdges(self, max_edges)

    def getMaxEdges(self):
        return _odb_py.dbTechLayerMinStepRule_getMaxEdges(self)

    def setMinAdjLength1(self, min_adj_length1):
        return _odb_py.dbTechLayerMinStepRule_setMinAdjLength1(self, min_adj_length1)

    def getMinAdjLength1(self):
        return _odb_py.dbTechLayerMinStepRule_getMinAdjLength1(self)

    def setMinAdjLength2(self, min_adj_length2):
        return _odb_py.dbTechLayerMinStepRule_setMinAdjLength2(self, min_adj_length2)

    def getMinAdjLength2(self):
        return _odb_py.dbTechLayerMinStepRule_getMinAdjLength2(self)

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerMinStepRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerMinStepRule_getEolWidth(self)

    def setMinBetweenLength(self, min_between_length):
        return _odb_py.dbTechLayerMinStepRule_setMinBetweenLength(self, min_between_length)

    def getMinBetweenLength(self):
        return _odb_py.dbTechLayerMinStepRule_getMinBetweenLength(self)

    def setMaxEdgesValid(self, max_edges_valid):
        return _odb_py.dbTechLayerMinStepRule_setMaxEdgesValid(self, max_edges_valid)

    def isMaxEdgesValid(self):
        return _odb_py.dbTechLayerMinStepRule_isMaxEdgesValid(self)

    def setMinAdjLength1Valid(self, min_adj_length1_valid):
        return _odb_py.dbTechLayerMinStepRule_setMinAdjLength1Valid(self, min_adj_length1_valid)

    def isMinAdjLength1Valid(self):
        return _odb_py.dbTechLayerMinStepRule_isMinAdjLength1Valid(self)

    def setNoBetweenEol(self, no_between_eol):
        return _odb_py.dbTechLayerMinStepRule_setNoBetweenEol(self, no_between_eol)

    def isNoBetweenEol(self):
        return _odb_py.dbTechLayerMinStepRule_isNoBetweenEol(self)

    def setMinAdjLength2Valid(self, min_adj_length2_valid):
        return _odb_py.dbTechLayerMinStepRule_setMinAdjLength2Valid(self, min_adj_length2_valid)

    def isMinAdjLength2Valid(self):
        return _odb_py.dbTechLayerMinStepRule_isMinAdjLength2Valid(self)

    def setConvexCorner(self, convex_corner):
        return _odb_py.dbTechLayerMinStepRule_setConvexCorner(self, convex_corner)

    def isConvexCorner(self):
        return _odb_py.dbTechLayerMinStepRule_isConvexCorner(self)

    def setMinBetweenLengthValid(self, min_between_length_valid):
        return _odb_py.dbTechLayerMinStepRule_setMinBetweenLengthValid(self, min_between_length_valid)

    def isMinBetweenLengthValid(self):
        return _odb_py.dbTechLayerMinStepRule_isMinBetweenLengthValid(self)

    def setExceptSameCorners(self, except_same_corners):
        return _odb_py.dbTechLayerMinStepRule_setExceptSameCorners(self, except_same_corners)

    def isExceptSameCorners(self):
        return _odb_py.dbTechLayerMinStepRule_isExceptSameCorners(self)

    def setConcaveCorner(self, concave_corner):
        return _odb_py.dbTechLayerMinStepRule_setConcaveCorner(self, concave_corner)

    def isConcaveCorner(self):
        return _odb_py.dbTechLayerMinStepRule_isConcaveCorner(self)

    def setExceptRectangle(self, except_rectangle):
        return _odb_py.dbTechLayerMinStepRule_setExceptRectangle(self, except_rectangle)

    def isExceptRectangle(self):
        return _odb_py.dbTechLayerMinStepRule_isExceptRectangle(self)

    def setNoAdjacentEol(self, no_adjacent_eol):
        return _odb_py.dbTechLayerMinStepRule_setNoAdjacentEol(self, no_adjacent_eol)

    def isNoAdjacentEol(self):
        return _odb_py.dbTechLayerMinStepRule_isNoAdjacentEol(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerMinStepRule_create(layer)

    @staticmethod
    def getTechLayerMinStepRule(inly, dbid):
        return _odb_py.dbTechLayerMinStepRule_getTechLayerMinStepRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerMinStepRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerMinStepRule_swiginit(self, _odb_py.new_dbTechLayerMinStepRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerMinStepRule

# Register dbTechLayerMinStepRule in _odb_py:
_odb_py.dbTechLayerMinStepRule_swigregister(dbTechLayerMinStepRule)

def dbTechLayerMinStepRule_create(layer):
    return _odb_py.dbTechLayerMinStepRule_create(layer)

def dbTechLayerMinStepRule_getTechLayerMinStepRule(inly, dbid):
    return _odb_py.dbTechLayerMinStepRule_getTechLayerMinStepRule(inly, dbid)

def dbTechLayerMinStepRule_destroy(rule):
    return _odb_py.dbTechLayerMinStepRule_destroy(rule)

class dbTechLayerSpacingEolRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setEolSpace(self, eol_space):
        return _odb_py.dbTechLayerSpacingEolRule_setEolSpace(self, eol_space)

    def getEolSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEolSpace(self)

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerSpacingEolRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEolWidth(self)

    def setWrongDirSpace(self, wrong_dir_space):
        return _odb_py.dbTechLayerSpacingEolRule_setWrongDirSpace(self, wrong_dir_space)

    def getWrongDirSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getWrongDirSpace(self)

    def setOppositeWidth(self, opposite_width):
        return _odb_py.dbTechLayerSpacingEolRule_setOppositeWidth(self, opposite_width)

    def getOppositeWidth(self):
        return _odb_py.dbTechLayerSpacingEolRule_getOppositeWidth(self)

    def setEolWithin(self, eol_within):
        return _odb_py.dbTechLayerSpacingEolRule_setEolWithin(self, eol_within)

    def getEolWithin(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEolWithin(self)

    def setWrongDirWithin(self, wrong_dir_within):
        return _odb_py.dbTechLayerSpacingEolRule_setWrongDirWithin(self, wrong_dir_within)

    def getWrongDirWithin(self):
        return _odb_py.dbTechLayerSpacingEolRule_getWrongDirWithin(self)

    def setExactWidth(self, exact_width):
        return _odb_py.dbTechLayerSpacingEolRule_setExactWidth(self, exact_width)

    def getExactWidth(self):
        return _odb_py.dbTechLayerSpacingEolRule_getExactWidth(self)

    def setOtherWidth(self, other_width):
        return _odb_py.dbTechLayerSpacingEolRule_setOtherWidth(self, other_width)

    def getOtherWidth(self):
        return _odb_py.dbTechLayerSpacingEolRule_getOtherWidth(self)

    def setFillTriangle(self, fill_triangle):
        return _odb_py.dbTechLayerSpacingEolRule_setFillTriangle(self, fill_triangle)

    def getFillTriangle(self):
        return _odb_py.dbTechLayerSpacingEolRule_getFillTriangle(self)

    def setCutClass(self, cut_class):
        return _odb_py.dbTechLayerSpacingEolRule_setCutClass(self, cut_class)

    def getCutClass(self):
        return _odb_py.dbTechLayerSpacingEolRule_getCutClass(self)

    def setWithCutSpace(self, with_cut_space):
        return _odb_py.dbTechLayerSpacingEolRule_setWithCutSpace(self, with_cut_space)

    def getWithCutSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getWithCutSpace(self)

    def setEnclosureEndWidth(self, enclosure_end_width):
        return _odb_py.dbTechLayerSpacingEolRule_setEnclosureEndWidth(self, enclosure_end_width)

    def getEnclosureEndWidth(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEnclosureEndWidth(self)

    def setEnclosureEndWithin(self, enclosure_end_within):
        return _odb_py.dbTechLayerSpacingEolRule_setEnclosureEndWithin(self, enclosure_end_within)

    def getEnclosureEndWithin(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEnclosureEndWithin(self)

    def setEndPrlSpace(self, end_prl_space):
        return _odb_py.dbTechLayerSpacingEolRule_setEndPrlSpace(self, end_prl_space)

    def getEndPrlSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEndPrlSpace(self)

    def setEndPrl(self, end_prl):
        return _odb_py.dbTechLayerSpacingEolRule_setEndPrl(self, end_prl)

    def getEndPrl(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEndPrl(self)

    def setEndToEndSpace(self, end_to_end_space):
        return _odb_py.dbTechLayerSpacingEolRule_setEndToEndSpace(self, end_to_end_space)

    def getEndToEndSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEndToEndSpace(self)

    def setOneCutSpace(self, one_cut_space):
        return _odb_py.dbTechLayerSpacingEolRule_setOneCutSpace(self, one_cut_space)

    def getOneCutSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getOneCutSpace(self)

    def setTwoCutSpace(self, two_cut_space):
        return _odb_py.dbTechLayerSpacingEolRule_setTwoCutSpace(self, two_cut_space)

    def getTwoCutSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getTwoCutSpace(self)

    def setExtension(self, extension):
        return _odb_py.dbTechLayerSpacingEolRule_setExtension(self, extension)

    def getExtension(self):
        return _odb_py.dbTechLayerSpacingEolRule_getExtension(self)

    def setWrongDirExtension(self, wrong_dir_extension):
        return _odb_py.dbTechLayerSpacingEolRule_setWrongDirExtension(self, wrong_dir_extension)

    def getWrongDirExtension(self):
        return _odb_py.dbTechLayerSpacingEolRule_getWrongDirExtension(self)

    def setOtherEndWidth(self, other_end_width):
        return _odb_py.dbTechLayerSpacingEolRule_setOtherEndWidth(self, other_end_width)

    def getOtherEndWidth(self):
        return _odb_py.dbTechLayerSpacingEolRule_getOtherEndWidth(self)

    def setMaxLength(self, max_length):
        return _odb_py.dbTechLayerSpacingEolRule_setMaxLength(self, max_length)

    def getMaxLength(self):
        return _odb_py.dbTechLayerSpacingEolRule_getMaxLength(self)

    def setMinLength(self, min_length):
        return _odb_py.dbTechLayerSpacingEolRule_setMinLength(self, min_length)

    def getMinLength(self):
        return _odb_py.dbTechLayerSpacingEolRule_getMinLength(self)

    def setParSpace(self, par_space):
        return _odb_py.dbTechLayerSpacingEolRule_setParSpace(self, par_space)

    def getParSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getParSpace(self)

    def setParWithin(self, par_within):
        return _odb_py.dbTechLayerSpacingEolRule_setParWithin(self, par_within)

    def getParWithin(self):
        return _odb_py.dbTechLayerSpacingEolRule_getParWithin(self)

    def setParPrl(self, par_prl):
        return _odb_py.dbTechLayerSpacingEolRule_setParPrl(self, par_prl)

    def getParPrl(self):
        return _odb_py.dbTechLayerSpacingEolRule_getParPrl(self)

    def setParMinLength(self, par_min_length):
        return _odb_py.dbTechLayerSpacingEolRule_setParMinLength(self, par_min_length)

    def getParMinLength(self):
        return _odb_py.dbTechLayerSpacingEolRule_getParMinLength(self)

    def setEncloseDist(self, enclose_dist):
        return _odb_py.dbTechLayerSpacingEolRule_setEncloseDist(self, enclose_dist)

    def getEncloseDist(self):
        return _odb_py.dbTechLayerSpacingEolRule_getEncloseDist(self)

    def setCutToMetalSpace(self, cut_to_metal_space):
        return _odb_py.dbTechLayerSpacingEolRule_setCutToMetalSpace(self, cut_to_metal_space)

    def getCutToMetalSpace(self):
        return _odb_py.dbTechLayerSpacingEolRule_getCutToMetalSpace(self)

    def setMinAdjLength(self, min_adj_length):
        return _odb_py.dbTechLayerSpacingEolRule_setMinAdjLength(self, min_adj_length)

    def getMinAdjLength(self):
        return _odb_py.dbTechLayerSpacingEolRule_getMinAdjLength(self)

    def setMinAdjLength1(self, min_adj_length1):
        return _odb_py.dbTechLayerSpacingEolRule_setMinAdjLength1(self, min_adj_length1)

    def getMinAdjLength1(self):
        return _odb_py.dbTechLayerSpacingEolRule_getMinAdjLength1(self)

    def setMinAdjLength2(self, min_adj_length2):
        return _odb_py.dbTechLayerSpacingEolRule_setMinAdjLength2(self, min_adj_length2)

    def getMinAdjLength2(self):
        return _odb_py.dbTechLayerSpacingEolRule_getMinAdjLength2(self)

    def setNotchLength(self, notch_length):
        return _odb_py.dbTechLayerSpacingEolRule_setNotchLength(self, notch_length)

    def getNotchLength(self):
        return _odb_py.dbTechLayerSpacingEolRule_getNotchLength(self)

    def setExactWidthValid(self, exact_width_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setExactWidthValid(self, exact_width_valid)

    def isExactWidthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isExactWidthValid(self)

    def setWrongDirSpacingValid(self, wrong_dir_spacing_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setWrongDirSpacingValid(self, wrong_dir_spacing_valid)

    def isWrongDirSpacingValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isWrongDirSpacingValid(self)

    def setOppositeWidthValid(self, opposite_width_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setOppositeWidthValid(self, opposite_width_valid)

    def isOppositeWidthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isOppositeWidthValid(self)

    def setWithinValid(self, within_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setWithinValid(self, within_valid)

    def isWithinValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isWithinValid(self)

    def setWrongDirWithinValid(self, wrong_dir_within_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setWrongDirWithinValid(self, wrong_dir_within_valid)

    def isWrongDirWithinValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isWrongDirWithinValid(self)

    def setSameMaskValid(self, same_mask_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setSameMaskValid(self, same_mask_valid)

    def isSameMaskValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isSameMaskValid(self)

    def setExceptExactWidthValid(self, except_exact_width_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setExceptExactWidthValid(self, except_exact_width_valid)

    def isExceptExactWidthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isExceptExactWidthValid(self)

    def setFillConcaveCornerValid(self, fill_concave_corner_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setFillConcaveCornerValid(self, fill_concave_corner_valid)

    def isFillConcaveCornerValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isFillConcaveCornerValid(self)

    def setWithcutValid(self, withcut_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setWithcutValid(self, withcut_valid)

    def isWithcutValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isWithcutValid(self)

    def setCutClassValid(self, cut_class_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setCutClassValid(self, cut_class_valid)

    def isCutClassValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isCutClassValid(self)

    def setWithCutAboveValid(self, with_cut_above_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setWithCutAboveValid(self, with_cut_above_valid)

    def isWithCutAboveValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isWithCutAboveValid(self)

    def setEnclosureEndValid(self, enclosure_end_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setEnclosureEndValid(self, enclosure_end_valid)

    def isEnclosureEndValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isEnclosureEndValid(self)

    def setEnclosureEndWithinValid(self, enclosure_end_within_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setEnclosureEndWithinValid(self, enclosure_end_within_valid)

    def isEnclosureEndWithinValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isEnclosureEndWithinValid(self)

    def setEndPrlSpacingValid(self, end_prl_spacing_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setEndPrlSpacingValid(self, end_prl_spacing_valid)

    def isEndPrlSpacingValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isEndPrlSpacingValid(self)

    def setPrlValid(self, prl_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setPrlValid(self, prl_valid)

    def isPrlValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isPrlValid(self)

    def setEndToEndValid(self, end_to_end_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setEndToEndValid(self, end_to_end_valid)

    def isEndToEndValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isEndToEndValid(self)

    def setCutSpacesValid(self, cut_spaces_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setCutSpacesValid(self, cut_spaces_valid)

    def isCutSpacesValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isCutSpacesValid(self)

    def setExtensionValid(self, extension_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setExtensionValid(self, extension_valid)

    def isExtensionValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isExtensionValid(self)

    def setWrongDirExtensionValid(self, wrong_dir_extension_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setWrongDirExtensionValid(self, wrong_dir_extension_valid)

    def isWrongDirExtensionValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isWrongDirExtensionValid(self)

    def setOtherEndWidthValid(self, other_end_width_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setOtherEndWidthValid(self, other_end_width_valid)

    def isOtherEndWidthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isOtherEndWidthValid(self)

    def setMaxLengthValid(self, max_length_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setMaxLengthValid(self, max_length_valid)

    def isMaxLengthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isMaxLengthValid(self)

    def setMinLengthValid(self, min_length_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setMinLengthValid(self, min_length_valid)

    def isMinLengthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isMinLengthValid(self)

    def setTwoSidesValid(self, two_sides_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setTwoSidesValid(self, two_sides_valid)

    def isTwoSidesValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isTwoSidesValid(self)

    def setEqualRectWidthValid(self, equal_rect_width_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setEqualRectWidthValid(self, equal_rect_width_valid)

    def isEqualRectWidthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isEqualRectWidthValid(self)

    def setParallelEdgeValid(self, parallel_edge_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setParallelEdgeValid(self, parallel_edge_valid)

    def isParallelEdgeValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isParallelEdgeValid(self)

    def setSubtractEolWidthValid(self, subtract_eol_width_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setSubtractEolWidthValid(self, subtract_eol_width_valid)

    def isSubtractEolWidthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isSubtractEolWidthValid(self)

    def setParPrlValid(self, par_prl_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setParPrlValid(self, par_prl_valid)

    def isParPrlValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isParPrlValid(self)

    def setParMinLengthValid(self, par_min_length_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setParMinLengthValid(self, par_min_length_valid)

    def isParMinLengthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isParMinLengthValid(self)

    def setTwoEdgesValid(self, two_edges_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setTwoEdgesValid(self, two_edges_valid)

    def isTwoEdgesValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isTwoEdgesValid(self)

    def setSameMetalValid(self, same_metal_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setSameMetalValid(self, same_metal_valid)

    def isSameMetalValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isSameMetalValid(self)

    def setNonEolCornerOnlyValid(self, non_eol_corner_only_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setNonEolCornerOnlyValid(self, non_eol_corner_only_valid)

    def isNonEolCornerOnlyValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isNonEolCornerOnlyValid(self)

    def setParallelSameMaskValid(self, parallel_same_mask_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setParallelSameMaskValid(self, parallel_same_mask_valid)

    def isParallelSameMaskValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isParallelSameMaskValid(self)

    def setEncloseCutValid(self, enclose_cut_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setEncloseCutValid(self, enclose_cut_valid)

    def isEncloseCutValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isEncloseCutValid(self)

    def setBelowValid(self, below_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setBelowValid(self, below_valid)

    def isBelowValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isBelowValid(self)

    def setAboveValid(self, above_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setAboveValid(self, above_valid)

    def isAboveValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isAboveValid(self)

    def setCutSpacingValid(self, cut_spacing_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setCutSpacingValid(self, cut_spacing_valid)

    def isCutSpacingValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isCutSpacingValid(self)

    def setAllCutsValid(self, all_cuts_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setAllCutsValid(self, all_cuts_valid)

    def isAllCutsValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isAllCutsValid(self)

    def setToConcaveCornerValid(self, to_concave_corner_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setToConcaveCornerValid(self, to_concave_corner_valid)

    def isToConcaveCornerValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isToConcaveCornerValid(self)

    def setMinAdjacentLengthValid(self, min_adjacent_length_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setMinAdjacentLengthValid(self, min_adjacent_length_valid)

    def isMinAdjacentLengthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isMinAdjacentLengthValid(self)

    def setTwoMinAdjLengthValid(self, two_min_adj_length_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setTwoMinAdjLengthValid(self, two_min_adj_length_valid)

    def isTwoMinAdjLengthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isTwoMinAdjLengthValid(self)

    def setToNotchLengthValid(self, to_notch_length_valid):
        return _odb_py.dbTechLayerSpacingEolRule_setToNotchLengthValid(self, to_notch_length_valid)

    def isToNotchLengthValid(self):
        return _odb_py.dbTechLayerSpacingEolRule_isToNotchLengthValid(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerSpacingEolRule_create(layer)

    @staticmethod
    def getTechLayerSpacingEolRule(inly, dbid):
        return _odb_py.dbTechLayerSpacingEolRule_getTechLayerSpacingEolRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerSpacingEolRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerSpacingEolRule_swiginit(self, _odb_py.new_dbTechLayerSpacingEolRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerSpacingEolRule

# Register dbTechLayerSpacingEolRule in _odb_py:
_odb_py.dbTechLayerSpacingEolRule_swigregister(dbTechLayerSpacingEolRule)

def dbTechLayerSpacingEolRule_create(layer):
    return _odb_py.dbTechLayerSpacingEolRule_create(layer)

def dbTechLayerSpacingEolRule_getTechLayerSpacingEolRule(inly, dbid):
    return _odb_py.dbTechLayerSpacingEolRule_getTechLayerSpacingEolRule(inly, dbid)

def dbTechLayerSpacingEolRule_destroy(rule):
    return _odb_py.dbTechLayerSpacingEolRule_destroy(rule)

class dbTechLayerSpacingTablePrlRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setEolWidth(self, eol_width):
        return _odb_py.dbTechLayerSpacingTablePrlRule_setEolWidth(self, eol_width)

    def getEolWidth(self):
        return _odb_py.dbTechLayerSpacingTablePrlRule_getEolWidth(self)

    def setWrongDirection(self, wrong_direction):
        return _odb_py.dbTechLayerSpacingTablePrlRule_setWrongDirection(self, wrong_direction)

    def isWrongDirection(self):
        return _odb_py.dbTechLayerSpacingTablePrlRule_isWrongDirection(self)

    def setSameMask(self, same_mask):
        return _odb_py.dbTechLayerSpacingTablePrlRule_setSameMask(self, same_mask)

    def isSameMask(self):
        return _odb_py.dbTechLayerSpacingTablePrlRule_isSameMask(self)

    def setExceeptEol(self, exceept_eol):
        return _odb_py.dbTechLayerSpacingTablePrlRule_setExceeptEol(self, exceept_eol)

    def isExceeptEol(self):
        return _odb_py.dbTechLayerSpacingTablePrlRule_isExceeptEol(self)

    @staticmethod
    def getTechLayerSpacingTablePrlRule(inly, dbid):
        return _odb_py.dbTechLayerSpacingTablePrlRule_getTechLayerSpacingTablePrlRule(inly, dbid)

    @staticmethod
    def create(_layer):
        return _odb_py.dbTechLayerSpacingTablePrlRule_create(_layer)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerSpacingTablePrlRule_destroy(rule)

    def setTable(self, width_tbl, length_tbl, spacing_tbl, excluded_map):
        return _odb_py.dbTechLayerSpacingTablePrlRule_setTable(self, width_tbl, length_tbl, spacing_tbl, excluded_map)

    def getTable(self, width_tbl, length_tbl, spacing_tbl, excluded_map):
        return _odb_py.dbTechLayerSpacingTablePrlRule_getTable(self, width_tbl, length_tbl, spacing_tbl, excluded_map)

    def setSpacingTableInfluence(self, influence_tbl):
        return _odb_py.dbTechLayerSpacingTablePrlRule_setSpacingTableInfluence(self, influence_tbl)

    def getSpacing(self, width, length):
        return _odb_py.dbTechLayerSpacingTablePrlRule_getSpacing(self, width, length)

    def hasExceptWithin(self, width):
        return _odb_py.dbTechLayerSpacingTablePrlRule_hasExceptWithin(self, width)

    def getExceptWithin(self, width):
        return _odb_py.dbTechLayerSpacingTablePrlRule_getExceptWithin(self, width)

    def __init__(self):
        _odb_py.dbTechLayerSpacingTablePrlRule_swiginit(self, _odb_py.new_dbTechLayerSpacingTablePrlRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerSpacingTablePrlRule

# Register dbTechLayerSpacingTablePrlRule in _odb_py:
_odb_py.dbTechLayerSpacingTablePrlRule_swigregister(dbTechLayerSpacingTablePrlRule)

def dbTechLayerSpacingTablePrlRule_getTechLayerSpacingTablePrlRule(inly, dbid):
    return _odb_py.dbTechLayerSpacingTablePrlRule_getTechLayerSpacingTablePrlRule(inly, dbid)

def dbTechLayerSpacingTablePrlRule_create(_layer):
    return _odb_py.dbTechLayerSpacingTablePrlRule_create(_layer)

def dbTechLayerSpacingTablePrlRule_destroy(rule):
    return _odb_py.dbTechLayerSpacingTablePrlRule_destroy(rule)

class dbTechLayerTwoWiresForbiddenSpcRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMinSpacing(self, min_spacing):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setMinSpacing(self, min_spacing)

    def getMinSpacing(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_getMinSpacing(self)

    def setMaxSpacing(self, max_spacing):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setMaxSpacing(self, max_spacing)

    def getMaxSpacing(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_getMaxSpacing(self)

    def setMinSpanLength(self, min_span_length):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setMinSpanLength(self, min_span_length)

    def getMinSpanLength(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_getMinSpanLength(self)

    def setMaxSpanLength(self, max_span_length):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setMaxSpanLength(self, max_span_length)

    def getMaxSpanLength(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_getMaxSpanLength(self)

    def setPrl(self, prl):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setPrl(self, prl)

    def getPrl(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_getPrl(self)

    def setMinExactSpanLength(self, min_exact_span_length):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setMinExactSpanLength(self, min_exact_span_length)

    def isMinExactSpanLength(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_isMinExactSpanLength(self)

    def setMaxExactSpanLength(self, max_exact_span_length):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_setMaxExactSpanLength(self, max_exact_span_length)

    def isMaxExactSpanLength(self):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_isMaxExactSpanLength(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_create(layer)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_swiginit(self, _odb_py.new_dbTechLayerTwoWiresForbiddenSpcRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerTwoWiresForbiddenSpcRule

# Register dbTechLayerTwoWiresForbiddenSpcRule in _odb_py:
_odb_py.dbTechLayerTwoWiresForbiddenSpcRule_swigregister(dbTechLayerTwoWiresForbiddenSpcRule)

def dbTechLayerTwoWiresForbiddenSpcRule_create(layer):
    return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_create(layer)

def dbTechLayerTwoWiresForbiddenSpcRule_destroy(rule):
    return _odb_py.dbTechLayerTwoWiresForbiddenSpcRule_destroy(rule)

class dbTechLayerWidthTableRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setWrongDirection(self, wrong_direction):
        return _odb_py.dbTechLayerWidthTableRule_setWrongDirection(self, wrong_direction)

    def isWrongDirection(self):
        return _odb_py.dbTechLayerWidthTableRule_isWrongDirection(self)

    def setOrthogonal(self, orthogonal):
        return _odb_py.dbTechLayerWidthTableRule_setOrthogonal(self, orthogonal)

    def isOrthogonal(self):
        return _odb_py.dbTechLayerWidthTableRule_isOrthogonal(self)

    def addWidth(self, width):
        return _odb_py.dbTechLayerWidthTableRule_addWidth(self, width)

    def getWidthTable(self):
        return _odb_py.dbTechLayerWidthTableRule_getWidthTable(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerWidthTableRule_create(layer)

    @staticmethod
    def getTechLayerWidthTableRule(inly, dbid):
        return _odb_py.dbTechLayerWidthTableRule_getTechLayerWidthTableRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerWidthTableRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerWidthTableRule_swiginit(self, _odb_py.new_dbTechLayerWidthTableRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerWidthTableRule

# Register dbTechLayerWidthTableRule in _odb_py:
_odb_py.dbTechLayerWidthTableRule_swigregister(dbTechLayerWidthTableRule)

def dbTechLayerWidthTableRule_create(layer):
    return _odb_py.dbTechLayerWidthTableRule_create(layer)

def dbTechLayerWidthTableRule_getTechLayerWidthTableRule(inly, dbid):
    return _odb_py.dbTechLayerWidthTableRule_getTechLayerWidthTableRule(inly, dbid)

def dbTechLayerWidthTableRule_destroy(rule):
    return _odb_py.dbTechLayerWidthTableRule_destroy(rule)

class dbTechLayerWrongDirSpacingRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setWrongdirSpace(self, wrongdir_space):
        return _odb_py.dbTechLayerWrongDirSpacingRule_setWrongdirSpace(self, wrongdir_space)

    def getWrongdirSpace(self):
        return _odb_py.dbTechLayerWrongDirSpacingRule_getWrongdirSpace(self)

    def setNoneolWidth(self, noneol_width):
        return _odb_py.dbTechLayerWrongDirSpacingRule_setNoneolWidth(self, noneol_width)

    def getNoneolWidth(self):
        return _odb_py.dbTechLayerWrongDirSpacingRule_getNoneolWidth(self)

    def setLength(self, length):
        return _odb_py.dbTechLayerWrongDirSpacingRule_setLength(self, length)

    def getLength(self):
        return _odb_py.dbTechLayerWrongDirSpacingRule_getLength(self)

    def setPrlLength(self, prl_length):
        return _odb_py.dbTechLayerWrongDirSpacingRule_setPrlLength(self, prl_length)

    def getPrlLength(self):
        return _odb_py.dbTechLayerWrongDirSpacingRule_getPrlLength(self)

    def setNoneolValid(self, noneol_valid):
        return _odb_py.dbTechLayerWrongDirSpacingRule_setNoneolValid(self, noneol_valid)

    def isNoneolValid(self):
        return _odb_py.dbTechLayerWrongDirSpacingRule_isNoneolValid(self)

    def setLengthValid(self, length_valid):
        return _odb_py.dbTechLayerWrongDirSpacingRule_setLengthValid(self, length_valid)

    def isLengthValid(self):
        return _odb_py.dbTechLayerWrongDirSpacingRule_isLengthValid(self)

    @staticmethod
    def create(layer):
        return _odb_py.dbTechLayerWrongDirSpacingRule_create(layer)

    @staticmethod
    def getTechLayerWrongDirSpacingRule(inly, dbid):
        return _odb_py.dbTechLayerWrongDirSpacingRule_getTechLayerWrongDirSpacingRule(inly, dbid)

    @staticmethod
    def destroy(rule):
        return _odb_py.dbTechLayerWrongDirSpacingRule_destroy(rule)

    def __init__(self):
        _odb_py.dbTechLayerWrongDirSpacingRule_swiginit(self, _odb_py.new_dbTechLayerWrongDirSpacingRule())
    __swig_destroy__ = _odb_py.delete_dbTechLayerWrongDirSpacingRule

# Register dbTechLayerWrongDirSpacingRule in _odb_py:
_odb_py.dbTechLayerWrongDirSpacingRule_swigregister(dbTechLayerWrongDirSpacingRule)

def dbTechLayerWrongDirSpacingRule_create(layer):
    return _odb_py.dbTechLayerWrongDirSpacingRule_create(layer)

def dbTechLayerWrongDirSpacingRule_getTechLayerWrongDirSpacingRule(inly, dbid):
    return _odb_py.dbTechLayerWrongDirSpacingRule_getTechLayerWrongDirSpacingRule(inly, dbid)

def dbTechLayerWrongDirSpacingRule_destroy(rule):
    return _odb_py.dbTechLayerWrongDirSpacingRule_destroy(rule)


def read_lef(db, path):
    return _odb_py.read_lef(db, path)

def write_lef(lib, path):
    return _odb_py.write_lef(lib, path)

def write_tech_lef(tech, path):
    return _odb_py.write_tech_lef(tech, path)

def write_macro_lef(lib, path):
    return _odb_py.write_macro_lef(lib, path)

def read_def(tech, path):
    return _odb_py.read_def(tech, path)

def write_def(*args):
    return _odb_py.write_def(*args)

def read_db(db, db_path):
    return _odb_py.read_db(db, db_path)

def write_db(db, db_path):
    return _odb_py.write_db(db, db_path)

def createSBoxes(*args):
    return _odb_py.createSBoxes(*args)

def dumpAPs(block, file_name):
    return _odb_py.dumpAPs(block, file_name)

def db_diff(db1, db2):
    return _odb_py.db_diff(db1, db2)

def db_def_diff(db1, def_filename):
    return _odb_py.db_def_diff(db1, def_filename)
class _dbViaParams(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    _x_cut_size = property(_odb_py._dbViaParams__x_cut_size_get, _odb_py._dbViaParams__x_cut_size_set)
    _y_cut_size = property(_odb_py._dbViaParams__y_cut_size_get, _odb_py._dbViaParams__y_cut_size_set)
    _x_cut_spacing = property(_odb_py._dbViaParams__x_cut_spacing_get, _odb_py._dbViaParams__x_cut_spacing_set)
    _y_cut_spacing = property(_odb_py._dbViaParams__y_cut_spacing_get, _odb_py._dbViaParams__y_cut_spacing_set)
    _x_top_enclosure = property(_odb_py._dbViaParams__x_top_enclosure_get, _odb_py._dbViaParams__x_top_enclosure_set)
    _y_top_enclosure = property(_odb_py._dbViaParams__y_top_enclosure_get, _odb_py._dbViaParams__y_top_enclosure_set)
    _x_bot_enclosure = property(_odb_py._dbViaParams__x_bot_enclosure_get, _odb_py._dbViaParams__x_bot_enclosure_set)
    _y_bot_enclosure = property(_odb_py._dbViaParams__y_bot_enclosure_get, _odb_py._dbViaParams__y_bot_enclosure_set)
    _num_cut_rows = property(_odb_py._dbViaParams__num_cut_rows_get, _odb_py._dbViaParams__num_cut_rows_set)
    _num_cut_cols = property(_odb_py._dbViaParams__num_cut_cols_get, _odb_py._dbViaParams__num_cut_cols_set)
    _x_origin = property(_odb_py._dbViaParams__x_origin_get, _odb_py._dbViaParams__x_origin_set)
    _y_origin = property(_odb_py._dbViaParams__y_origin_get, _odb_py._dbViaParams__y_origin_set)
    _x_top_offset = property(_odb_py._dbViaParams__x_top_offset_get, _odb_py._dbViaParams__x_top_offset_set)
    _y_top_offset = property(_odb_py._dbViaParams__y_top_offset_get, _odb_py._dbViaParams__y_top_offset_set)
    _x_bot_offset = property(_odb_py._dbViaParams__x_bot_offset_get, _odb_py._dbViaParams__x_bot_offset_set)
    _y_bot_offset = property(_odb_py._dbViaParams__y_bot_offset_get, _odb_py._dbViaParams__y_bot_offset_set)
    _top_layer = property(_odb_py._dbViaParams__top_layer_get, _odb_py._dbViaParams__top_layer_set)
    _cut_layer = property(_odb_py._dbViaParams__cut_layer_get, _odb_py._dbViaParams__cut_layer_set)
    _bot_layer = property(_odb_py._dbViaParams__bot_layer_get, _odb_py._dbViaParams__bot_layer_set)

    def __init__(self, *args):
        _odb_py._dbViaParams_swiginit(self, _odb_py.new__dbViaParams(*args))
    __swig_destroy__ = _odb_py.delete__dbViaParams

    def __eq__(self, rhs):
        return _odb_py._dbViaParams___eq__(self, rhs)

    def __ne__(self, rhs):
        return _odb_py._dbViaParams___ne__(self, rhs)

    def differences(self, diff, field, rhs):
        return _odb_py._dbViaParams_differences(self, diff, field, rhs)

    def out(self, diff, side, field):
        return _odb_py._dbViaParams_out(self, diff, side, field)

# Register _dbViaParams in _odb_py:
_odb_py._dbViaParams_swigregister(_dbViaParams)

class dbWireEncoder(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _odb_py.dbWireEncoder_swiginit(self, _odb_py.new_dbWireEncoder())
    __swig_destroy__ = _odb_py.delete_dbWireEncoder

    def begin(self, wire):
        return _odb_py.dbWireEncoder_begin(self, wire)

    def append(self, wire):
        return _odb_py.dbWireEncoder_append(self, wire)

    def addPoint(self, *args):
        return _odb_py.dbWireEncoder_addPoint(self, *args)

    def addVia(self, via):
        return _odb_py.dbWireEncoder_addVia(self, via)

    def addTechVia(self, via):
        return _odb_py.dbWireEncoder_addTechVia(self, via)

    def addRect(self, deltaX1, deltaY1, deltaX2, deltaY2):
        return _odb_py.dbWireEncoder_addRect(self, deltaX1, deltaY1, deltaX2, deltaY2)

    def setColor(self, mask_color):
        return _odb_py.dbWireEncoder_setColor(self, mask_color)

    def clearColor(self):
        return _odb_py.dbWireEncoder_clearColor(self)

    def setViaColor(self, bottom_color, cut_color, top_color):
        return _odb_py.dbWireEncoder_setViaColor(self, bottom_color, cut_color, top_color)

    def clearViaColor(self):
        return _odb_py.dbWireEncoder_clearViaColor(self)

    def addITerm(self, iterm):
        return _odb_py.dbWireEncoder_addITerm(self, iterm)

    def addBTerm(self, bterm):
        return _odb_py.dbWireEncoder_addBTerm(self, bterm)

    def newPathShort(self, *args):
        return _odb_py.dbWireEncoder_newPathShort(self, *args)

    def newPathVirtualWire(self, *args):
        return _odb_py.dbWireEncoder_newPathVirtualWire(self, *args)

    def end(self):
        return _odb_py.dbWireEncoder_end(self)

    def clear(self):
        return _odb_py.dbWireEncoder_clear(self)

    def newPath(self, *args):
        return _odb_py.dbWireEncoder_newPath(self, *args)

    def newPathExt(self, *args):
        return _odb_py.dbWireEncoder_newPathExt(self, *args)

# Register dbWireEncoder in _odb_py:
_odb_py.dbWireEncoder_swigregister(dbWireEncoder)

class dbWireDecoder(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PATH = _odb_py.dbWireDecoder_PATH
    JUNCTION = _odb_py.dbWireDecoder_JUNCTION
    SHORT = _odb_py.dbWireDecoder_SHORT
    VWIRE = _odb_py.dbWireDecoder_VWIRE
    POINT = _odb_py.dbWireDecoder_POINT
    POINT_EXT = _odb_py.dbWireDecoder_POINT_EXT
    VIA = _odb_py.dbWireDecoder_VIA
    TECH_VIA = _odb_py.dbWireDecoder_TECH_VIA
    RECT = _odb_py.dbWireDecoder_RECT
    ITERM = _odb_py.dbWireDecoder_ITERM
    BTERM = _odb_py.dbWireDecoder_BTERM
    RULE = _odb_py.dbWireDecoder_RULE
    END_DECODE = _odb_py.dbWireDecoder_END_DECODE

    def __init__(self):
        _odb_py.dbWireDecoder_swiginit(self, _odb_py.new_dbWireDecoder())
    __swig_destroy__ = _odb_py.delete_dbWireDecoder

    def begin(self, wire):
        return _odb_py.dbWireDecoder_begin(self, wire)

    def next(self):
        return _odb_py.dbWireDecoder_next(self)

    def peek(self):
        return _odb_py.dbWireDecoder_peek(self)

    def getLayer(self):
        return _odb_py.dbWireDecoder_getLayer(self)

    def getPoint(self, *args):
        return _odb_py.dbWireDecoder_getPoint(self, *args)

    def getProperty(self):
        return _odb_py.dbWireDecoder_getProperty(self)

    def getVia(self):
        return _odb_py.dbWireDecoder_getVia(self)

    def getTechVia(self):
        return _odb_py.dbWireDecoder_getTechVia(self)

    def getRect(self, deltaX1, deltaY1, deltaX2, deltaY2):
        return _odb_py.dbWireDecoder_getRect(self, deltaX1, deltaY1, deltaX2, deltaY2)

    def getITerm(self):
        return _odb_py.dbWireDecoder_getITerm(self)

    def getBTerm(self):
        return _odb_py.dbWireDecoder_getBTerm(self)

    def getWireType(self):
        return _odb_py.dbWireDecoder_getWireType(self)

    def getRule(self):
        return _odb_py.dbWireDecoder_getRule(self)

    def getJunctionId(self):
        return _odb_py.dbWireDecoder_getJunctionId(self)

    def getJunctionValue(self):
        return _odb_py.dbWireDecoder_getJunctionValue(self)

    def getColor(self):
        return _odb_py.dbWireDecoder_getColor(self)

    def getViaColor(self):
        return _odb_py.dbWireDecoder_getViaColor(self)

# Register dbWireDecoder in _odb_py:
_odb_py.dbWireDecoder_swigregister(dbWireDecoder)


def dumpDecoder(inblk, net_name_or_id):
    return _odb_py.dumpDecoder(inblk, net_name_or_id)

def dumpDecoder4Net(innet):
    return _odb_py.dumpDecoder4Net(innet)
class dbBlockCallBackObj(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def inDbInstCreate(self, *args):
        return _odb_py.dbBlockCallBackObj_inDbInstCreate(self, *args)

    def inDbInstDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbInstDestroy(self, arg2)

    def inDbInstPlacementStatusBefore(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbInstPlacementStatusBefore(self, arg2, arg3)

    def inDbInstSwapMasterBefore(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbInstSwapMasterBefore(self, arg2, arg3)

    def inDbInstSwapMasterAfter(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbInstSwapMasterAfter(self, arg2)

    def inDbPreMoveInst(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbPreMoveInst(self, arg2)

    def inDbPostMoveInst(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbPostMoveInst(self, arg2)

    def inDbNetCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbNetCreate(self, arg2)

    def inDbNetDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbNetDestroy(self, arg2)

    def inDbITermCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbITermCreate(self, arg2)

    def inDbITermDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbITermDestroy(self, arg2)

    def inDbITermPreDisconnect(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbITermPreDisconnect(self, arg2)

    def inDbITermPostDisconnect(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbITermPostDisconnect(self, arg2, arg3)

    def inDbITermPreConnect(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbITermPreConnect(self, arg2, arg3)

    def inDbITermPostConnect(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbITermPostConnect(self, arg2)

    def inDbBTermCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBTermCreate(self, arg2)

    def inDbBTermDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBTermDestroy(self, arg2)

    def inDbBTermPreConnect(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbBTermPreConnect(self, arg2, arg3)

    def inDbBTermPostConnect(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBTermPostConnect(self, arg2)

    def inDbBTermPreDisconnect(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBTermPreDisconnect(self, arg2)

    def inDbBTermPostDisConnect(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbBTermPostDisConnect(self, arg2, arg3)

    def inDbBTermSetIoType(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbBTermSetIoType(self, arg2, arg3)

    def inDbBPinCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBPinCreate(self, arg2)

    def inDbBPinDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBPinDestroy(self, arg2)

    def inDbBlockageCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBlockageCreate(self, arg2)

    def inDbObstructionCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbObstructionCreate(self, arg2)

    def inDbObstructionDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbObstructionDestroy(self, arg2)

    def inDbRegionCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbRegionCreate(self, arg2)

    def inDbRegionAddBox(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbRegionAddBox(self, arg2, arg3)

    def inDbRegionDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbRegionDestroy(self, arg2)

    def inDbRowCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbRowCreate(self, arg2)

    def inDbRowDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbRowDestroy(self, arg2)

    def inDbWireCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbWireCreate(self, arg2)

    def inDbWireDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbWireDestroy(self, arg2)

    def inDbWirePostModify(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbWirePostModify(self, arg2)

    def inDbWirePreAttach(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbWirePreAttach(self, arg2, arg3)

    def inDbWirePostAttach(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbWirePostAttach(self, arg2)

    def inDbWirePreDetach(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbWirePreDetach(self, arg2)

    def inDbWirePostDetach(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbWirePostDetach(self, arg2, arg3)

    def inDbWirePreAppend(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbWirePreAppend(self, arg2, arg3)

    def inDbWirePostAppend(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbWirePostAppend(self, arg2, arg3)

    def inDbWirePreCopy(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbWirePreCopy(self, arg2, arg3)

    def inDbWirePostCopy(self, arg2, arg3):
        return _odb_py.dbBlockCallBackObj_inDbWirePostCopy(self, arg2, arg3)

    def inDbSWireCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbSWireCreate(self, arg2)

    def inDbSWireDestroy(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbSWireDestroy(self, arg2)

    def inDbSWireAddSBox(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbSWireAddSBox(self, arg2)

    def inDbSWireRemoveSBox(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbSWireRemoveSBox(self, arg2)

    def inDbSWirePreDestroySBoxes(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbSWirePreDestroySBoxes(self, arg2)

    def inDbSWirePostDestroySBoxes(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbSWirePostDestroySBoxes(self, arg2)

    def inDbFillCreate(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbFillCreate(self, arg2)

    def inDbBlockStreamOutBefore(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBlockStreamOutBefore(self, arg2)

    def inDbBlockStreamOutAfter(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBlockStreamOutAfter(self, arg2)

    def inDbBlockReadNetsBefore(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBlockReadNetsBefore(self, arg2)

    def inDbBlockSetDieArea(self, arg2):
        return _odb_py.dbBlockCallBackObj_inDbBlockSetDieArea(self, arg2)

    def __call__(self):
        return _odb_py.dbBlockCallBackObj___call__(self)

    def addOwner(self, new_owner):
        return _odb_py.dbBlockCallBackObj_addOwner(self, new_owner)

    def hasOwner(self):
        return _odb_py.dbBlockCallBackObj_hasOwner(self)

    def removeOwner(self):
        return _odb_py.dbBlockCallBackObj_removeOwner(self)

    def __init__(self):
        _odb_py.dbBlockCallBackObj_swiginit(self, _odb_py.new_dbBlockCallBackObj())
    __swig_destroy__ = _odb_py.delete_dbBlockCallBackObj

# Register dbBlockCallBackObj in _odb_py:
_odb_py.dbBlockCallBackObj_swigregister(dbBlockCallBackObj)

class dbIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reversible(self):
        return _odb_py.dbIterator_reversible(self)

    def orderReversed(self):
        return _odb_py.dbIterator_orderReversed(self)

    def reverse(self, parent):
        return _odb_py.dbIterator_reverse(self, parent)

    def sequential(self):
        return _odb_py.dbIterator_sequential(self)

    def size(self, parent):
        return _odb_py.dbIterator_size(self, parent)

    def begin(self, parent):
        return _odb_py.dbIterator_begin(self, parent)

    def end(self, parent):
        return _odb_py.dbIterator_end(self, parent)

    def next(self, id):
        return _odb_py.dbIterator_next(self, id)

    def getObject(self, id):
        return _odb_py.dbIterator_getObject(self, id)
    __swig_destroy__ = _odb_py.delete_dbIterator

# Register dbIterator in _odb_py:
_odb_py.dbIterator_swigregister(dbIterator)

class dbTransform(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _odb_py.dbTransform_swiginit(self, _odb_py.new_dbTransform(*args))

    def __eq__(self, t):
        return _odb_py.dbTransform___eq__(self, t)

    def __ne__(self, t):
        return _odb_py.dbTransform___ne__(self, t)

    def setOrient(self, orient):
        return _odb_py.dbTransform_setOrient(self, orient)

    def setOffset(self, offset):
        return _odb_py.dbTransform_setOffset(self, offset)

    def setTransform(self, orient, offset):
        return _odb_py.dbTransform_setTransform(self, orient, offset)

    def apply(self, *args):
        return _odb_py.dbTransform_apply(self, *args)

    def concat(self, *args):
        return _odb_py.dbTransform_concat(self, *args)

    def invert(self, *args):
        return _odb_py.dbTransform_invert(self, *args)

    def getOrient(self):
        return _odb_py.dbTransform_getOrient(self)

    def getOffset(self):
        return _odb_py.dbTransform_getOffset(self)
    __swig_destroy__ = _odb_py.delete_dbTransform

# Register dbTransform in _odb_py:
_odb_py.dbTransform_swigregister(dbTransform)


def __rshift__(*args):
    return _odb_py.__rshift__(*args)

def __lshift__(*args):
    return _odb_py.__lshift__(*args)
class dbWireGraph(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _odb_py.dbWireGraph_swiginit(self, _odb_py.new_dbWireGraph())
    __swig_destroy__ = _odb_py.delete_dbWireGraph

    def clear(self):
        return _odb_py.dbWireGraph_clear(self)

    def decode(self, wire):
        return _odb_py.dbWireGraph_decode(self, wire)

    def encode(self, wire):
        return _odb_py.dbWireGraph_encode(self, wire)

    def getEdge(self, shape_id):
        return _odb_py.dbWireGraph_getEdge(self, shape_id)

    def createNode(self, x, y, l):
        return _odb_py.dbWireGraph_createNode(self, x, y, l)

    def createVia(self, *args):
        return _odb_py.dbWireGraph_createVia(self, *args)

    def createTechVia(self, *args):
        return _odb_py.dbWireGraph_createTechVia(self, *args)

    def createSegment(self, *args):
        return _odb_py.dbWireGraph_createSegment(self, *args)

    def createShort(self, *args):
        return _odb_py.dbWireGraph_createShort(self, *args)

    def createVWire(self, *args):
        return _odb_py.dbWireGraph_createVWire(self, *args)

    def begin_nodes(self):
        return _odb_py.dbWireGraph_begin_nodes(self)

    def end_nodes(self):
        return _odb_py.dbWireGraph_end_nodes(self)

    def begin_edges(self):
        return _odb_py.dbWireGraph_begin_edges(self)

    def end_edges(self):
        return _odb_py.dbWireGraph_end_edges(self)

    def deleteNode(self, *args):
        return _odb_py.dbWireGraph_deleteNode(self, *args)

    def deleteEdge(self, *args):
        return _odb_py.dbWireGraph_deleteEdge(self, *args)

    def dump(self, logger):
        return _odb_py.dbWireGraph_dump(self, logger)

# Register dbWireGraph in _odb_py:
_odb_py.dbWireGraph_swigregister(dbWireGraph)


def orderWires(*args):
    return _odb_py.orderWires(*args)

def generateMacroPlacementString(block):
    return _odb_py.generateMacroPlacementString(block)