Source code for molpher.swig_wrappers.core

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_core')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_core')
    _core = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_core', [dirname(__file__)])
        except ImportError:
            import _core
            return _core
        try:
            _mod = imp.load_module('_core', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _core = swig_import_helper()
    del swig_import_helper
else:
    import _core
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _core.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _core.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _core.SHARED_PTR_DISOWN

def load_data_from(path):
    return _core.load_data_from(path)
load_data_from = _core.load_data_from

def set_random_seed(seed):
    return _core.set_random_seed(seed)
set_random_seed = _core.set_random_seed

def get_random_number(min, max):
    return _core.get_random_number(min, max)
get_random_number = _core.get_random_number
class StringSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.StringSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.StringSet___nonzero__(self)

    def __bool__(self):
        return _core.StringSet___bool__(self)

    def __len__(self):
        return _core.StringSet___len__(self)

    def append(self, x):
        return _core.StringSet_append(self, x)

    def __contains__(self, x):
        return _core.StringSet___contains__(self, x)

    def __getitem__(self, i):
        return _core.StringSet___getitem__(self, i)

    def add(self, x):
        return _core.StringSet_add(self, x)

    def discard(self, x):
        return _core.StringSet_discard(self, x)

    def __init__(self, *args):
        this = _core.new_StringSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _core.StringSet_empty(self)

    def size(self):
        return _core.StringSet_size(self)

    def clear(self):
        return _core.StringSet_clear(self)

    def swap(self, v):
        return _core.StringSet_swap(self, v)

    def count(self, x):
        return _core.StringSet_count(self, x)

    def begin(self):
        return _core.StringSet_begin(self)

    def end(self):
        return _core.StringSet_end(self)

    def rbegin(self):
        return _core.StringSet_rbegin(self)

    def rend(self):
        return _core.StringSet_rend(self)

    def erase(self, *args):
        return _core.StringSet_erase(self, *args)

    def find(self, x):
        return _core.StringSet_find(self, x)

    def lower_bound(self, x):
        return _core.StringSet_lower_bound(self, x)

    def upper_bound(self, x):
        return _core.StringSet_upper_bound(self, x)

    def equal_range(self, x):
        return _core.StringSet_equal_range(self, x)

    def insert(self, __x):
        return _core.StringSet_insert(self, __x)
    __swig_destroy__ = _core.delete_StringSet
    __del__ = lambda self: None
StringSet_swigregister = _core.StringSet_swigregister
StringSet_swigregister(StringSet)

class IntSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntSet, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.IntSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.IntSet___nonzero__(self)

    def __bool__(self):
        return _core.IntSet___bool__(self)

    def __len__(self):
        return _core.IntSet___len__(self)

    def append(self, x):
        return _core.IntSet_append(self, x)

    def __contains__(self, x):
        return _core.IntSet___contains__(self, x)

    def __getitem__(self, i):
        return _core.IntSet___getitem__(self, i)

    def add(self, x):
        return _core.IntSet_add(self, x)

    def discard(self, x):
        return _core.IntSet_discard(self, x)

    def __init__(self, *args):
        this = _core.new_IntSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _core.IntSet_empty(self)

    def size(self):
        return _core.IntSet_size(self)

    def clear(self):
        return _core.IntSet_clear(self)

    def swap(self, v):
        return _core.IntSet_swap(self, v)

    def count(self, x):
        return _core.IntSet_count(self, x)

    def begin(self):
        return _core.IntSet_begin(self)

    def end(self):
        return _core.IntSet_end(self)

    def rbegin(self):
        return _core.IntSet_rbegin(self)

    def rend(self):
        return _core.IntSet_rend(self)

    def erase(self, *args):
        return _core.IntSet_erase(self, *args)

    def find(self, x):
        return _core.IntSet_find(self, x)

    def lower_bound(self, x):
        return _core.IntSet_lower_bound(self, x)

    def upper_bound(self, x):
        return _core.IntSet_upper_bound(self, x)

    def equal_range(self, x):
        return _core.IntSet_equal_range(self, x)

    def insert(self, __x):
        return _core.IntSet_insert(self, __x)
    __swig_destroy__ = _core.delete_IntSet
    __del__ = lambda self: None
IntSet_swigregister = _core.IntSet_swigregister
IntSet_swigregister(IntSet)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.StringVector___nonzero__(self)

    def __bool__(self):
        return _core.StringVector___bool__(self)

    def __len__(self):
        return _core.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _core.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.StringVector___setitem__(self, *args)

    def pop(self):
        return _core.StringVector_pop(self)

    def append(self, x):
        return _core.StringVector_append(self, x)

    def empty(self):
        return _core.StringVector_empty(self)

    def size(self):
        return _core.StringVector_size(self)

    def swap(self, v):
        return _core.StringVector_swap(self, v)

    def begin(self):
        return _core.StringVector_begin(self)

    def end(self):
        return _core.StringVector_end(self)

    def rbegin(self):
        return _core.StringVector_rbegin(self)

    def rend(self):
        return _core.StringVector_rend(self)

    def clear(self):
        return _core.StringVector_clear(self)

    def get_allocator(self):
        return _core.StringVector_get_allocator(self)

    def pop_back(self):
        return _core.StringVector_pop_back(self)

    def erase(self, *args):
        return _core.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_StringVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.StringVector_push_back(self, x)

    def front(self):
        return _core.StringVector_front(self)

    def back(self):
        return _core.StringVector_back(self)

    def assign(self, n, x):
        return _core.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _core.StringVector_resize(self, *args)

    def insert(self, *args):
        return _core.StringVector_insert(self, *args)

    def reserve(self, n):
        return _core.StringVector_reserve(self, n)

    def capacity(self):
        return _core.StringVector_capacity(self)
    __swig_destroy__ = _core.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _core.StringVector_swigregister
StringVector_swigregister(StringVector)

class IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.IntVector___nonzero__(self)

    def __bool__(self):
        return _core.IntVector___bool__(self)

    def __len__(self):
        return _core.IntVector___len__(self)

    def __getslice__(self, i, j):
        return _core.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.IntVector___setitem__(self, *args)

    def pop(self):
        return _core.IntVector_pop(self)

    def append(self, x):
        return _core.IntVector_append(self, x)

    def empty(self):
        return _core.IntVector_empty(self)

    def size(self):
        return _core.IntVector_size(self)

    def swap(self, v):
        return _core.IntVector_swap(self, v)

    def begin(self):
        return _core.IntVector_begin(self)

    def end(self):
        return _core.IntVector_end(self)

    def rbegin(self):
        return _core.IntVector_rbegin(self)

    def rend(self):
        return _core.IntVector_rend(self)

    def clear(self):
        return _core.IntVector_clear(self)

    def get_allocator(self):
        return _core.IntVector_get_allocator(self)

    def pop_back(self):
        return _core.IntVector_pop_back(self)

    def erase(self, *args):
        return _core.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_IntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.IntVector_push_back(self, x)

    def front(self):
        return _core.IntVector_front(self)

    def back(self):
        return _core.IntVector_back(self)

    def assign(self, n, x):
        return _core.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _core.IntVector_resize(self, *args)

    def insert(self, *args):
        return _core.IntVector_insert(self, *args)

    def reserve(self, n):
        return _core.IntVector_reserve(self, n)

    def capacity(self):
        return _core.IntVector_capacity(self)
    __swig_destroy__ = _core.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _core.IntVector_swigregister
IntVector_swigregister(IntVector)

class UIntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UIntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UIntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.UIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.UIntVector___nonzero__(self)

    def __bool__(self):
        return _core.UIntVector___bool__(self)

    def __len__(self):
        return _core.UIntVector___len__(self)

    def __getslice__(self, i, j):
        return _core.UIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.UIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.UIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.UIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.UIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.UIntVector___setitem__(self, *args)

    def pop(self):
        return _core.UIntVector_pop(self)

    def append(self, x):
        return _core.UIntVector_append(self, x)

    def empty(self):
        return _core.UIntVector_empty(self)

    def size(self):
        return _core.UIntVector_size(self)

    def swap(self, v):
        return _core.UIntVector_swap(self, v)

    def begin(self):
        return _core.UIntVector_begin(self)

    def end(self):
        return _core.UIntVector_end(self)

    def rbegin(self):
        return _core.UIntVector_rbegin(self)

    def rend(self):
        return _core.UIntVector_rend(self)

    def clear(self):
        return _core.UIntVector_clear(self)

    def get_allocator(self):
        return _core.UIntVector_get_allocator(self)

    def pop_back(self):
        return _core.UIntVector_pop_back(self)

    def erase(self, *args):
        return _core.UIntVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_UIntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.UIntVector_push_back(self, x)

    def front(self):
        return _core.UIntVector_front(self)

    def back(self):
        return _core.UIntVector_back(self)

    def assign(self, n, x):
        return _core.UIntVector_assign(self, n, x)

    def resize(self, *args):
        return _core.UIntVector_resize(self, *args)

    def insert(self, *args):
        return _core.UIntVector_insert(self, *args)

    def reserve(self, n):
        return _core.UIntVector_reserve(self, n)

    def capacity(self):
        return _core.UIntVector_capacity(self)
    __swig_destroy__ = _core.delete_UIntVector
    __del__ = lambda self: None
UIntVector_swigregister = _core.UIntVector_swigregister
UIntVector_swigregister(UIntVector)

class UIntVectorPairVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UIntVectorPairVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UIntVectorPairVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.UIntVectorPairVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.UIntVectorPairVector___nonzero__(self)

    def __bool__(self):
        return _core.UIntVectorPairVector___bool__(self)

    def __len__(self):
        return _core.UIntVectorPairVector___len__(self)

    def __getslice__(self, i, j):
        return _core.UIntVectorPairVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.UIntVectorPairVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.UIntVectorPairVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.UIntVectorPairVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.UIntVectorPairVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.UIntVectorPairVector___setitem__(self, *args)

    def pop(self):
        return _core.UIntVectorPairVector_pop(self)

    def append(self, x):
        return _core.UIntVectorPairVector_append(self, x)

    def empty(self):
        return _core.UIntVectorPairVector_empty(self)

    def size(self):
        return _core.UIntVectorPairVector_size(self)

    def swap(self, v):
        return _core.UIntVectorPairVector_swap(self, v)

    def begin(self):
        return _core.UIntVectorPairVector_begin(self)

    def end(self):
        return _core.UIntVectorPairVector_end(self)

    def rbegin(self):
        return _core.UIntVectorPairVector_rbegin(self)

    def rend(self):
        return _core.UIntVectorPairVector_rend(self)

    def clear(self):
        return _core.UIntVectorPairVector_clear(self)

    def get_allocator(self):
        return _core.UIntVectorPairVector_get_allocator(self)

    def pop_back(self):
        return _core.UIntVectorPairVector_pop_back(self)

    def erase(self, *args):
        return _core.UIntVectorPairVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_UIntVectorPairVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.UIntVectorPairVector_push_back(self, x)

    def front(self):
        return _core.UIntVectorPairVector_front(self)

    def back(self):
        return _core.UIntVectorPairVector_back(self)

    def assign(self, n, x):
        return _core.UIntVectorPairVector_assign(self, n, x)

    def resize(self, *args):
        return _core.UIntVectorPairVector_resize(self, *args)

    def insert(self, *args):
        return _core.UIntVectorPairVector_insert(self, *args)

    def reserve(self, n):
        return _core.UIntVectorPairVector_reserve(self, n)

    def capacity(self):
        return _core.UIntVectorPairVector_capacity(self)
    __swig_destroy__ = _core.delete_UIntVectorPairVector
    __del__ = lambda self: None
UIntVectorPairVector_swigregister = _core.UIntVectorPairVector_swigregister
UIntVectorPairVector_swigregister(UIntVectorPairVector)

class BoolVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoolVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BoolVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.BoolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.BoolVector___nonzero__(self)

    def __bool__(self):
        return _core.BoolVector___bool__(self)

    def __len__(self):
        return _core.BoolVector___len__(self)

    def __getslice__(self, i, j):
        return _core.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.BoolVector___setitem__(self, *args)

    def pop(self):
        return _core.BoolVector_pop(self)

    def append(self, x):
        return _core.BoolVector_append(self, x)

    def empty(self):
        return _core.BoolVector_empty(self)

    def size(self):
        return _core.BoolVector_size(self)

    def swap(self, v):
        return _core.BoolVector_swap(self, v)

    def begin(self):
        return _core.BoolVector_begin(self)

    def end(self):
        return _core.BoolVector_end(self)

    def rbegin(self):
        return _core.BoolVector_rbegin(self)

    def rend(self):
        return _core.BoolVector_rend(self)

    def clear(self):
        return _core.BoolVector_clear(self)

    def get_allocator(self):
        return _core.BoolVector_get_allocator(self)

    def pop_back(self):
        return _core.BoolVector_pop_back(self)

    def erase(self, *args):
        return _core.BoolVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_BoolVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.BoolVector_push_back(self, x)

    def front(self):
        return _core.BoolVector_front(self)

    def back(self):
        return _core.BoolVector_back(self)

    def assign(self, n, x):
        return _core.BoolVector_assign(self, n, x)

    def resize(self, *args):
        return _core.BoolVector_resize(self, *args)

    def insert(self, *args):
        return _core.BoolVector_insert(self, *args)

    def reserve(self, n):
        return _core.BoolVector_reserve(self, n)

    def capacity(self):
        return _core.BoolVector_capacity(self)
    __swig_destroy__ = _core.delete_BoolVector
    __del__ = lambda self: None
BoolVector_swigregister = _core.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

class MolpherMolVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolpherMolVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MolpherMolVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.MolpherMolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MolpherMolVector___nonzero__(self)

    def __bool__(self):
        return _core.MolpherMolVector___bool__(self)

    def __len__(self):
        return _core.MolpherMolVector___len__(self)

    def __getslice__(self, i, j):
        return _core.MolpherMolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.MolpherMolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.MolpherMolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.MolpherMolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.MolpherMolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.MolpherMolVector___setitem__(self, *args)

    def pop(self):
        return _core.MolpherMolVector_pop(self)

    def append(self, x):
        return _core.MolpherMolVector_append(self, x)

    def empty(self):
        return _core.MolpherMolVector_empty(self)

    def size(self):
        return _core.MolpherMolVector_size(self)

    def swap(self, v):
        return _core.MolpherMolVector_swap(self, v)

    def begin(self):
        return _core.MolpherMolVector_begin(self)

    def end(self):
        return _core.MolpherMolVector_end(self)

    def rbegin(self):
        return _core.MolpherMolVector_rbegin(self)

    def rend(self):
        return _core.MolpherMolVector_rend(self)

    def clear(self):
        return _core.MolpherMolVector_clear(self)

    def get_allocator(self):
        return _core.MolpherMolVector_get_allocator(self)

    def pop_back(self):
        return _core.MolpherMolVector_pop_back(self)

    def erase(self, *args):
        return _core.MolpherMolVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_MolpherMolVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.MolpherMolVector_push_back(self, x)

    def front(self):
        return _core.MolpherMolVector_front(self)

    def back(self):
        return _core.MolpherMolVector_back(self)

    def assign(self, n, x):
        return _core.MolpherMolVector_assign(self, n, x)

    def resize(self, *args):
        return _core.MolpherMolVector_resize(self, *args)

    def insert(self, *args):
        return _core.MolpherMolVector_insert(self, *args)

    def reserve(self, n):
        return _core.MolpherMolVector_reserve(self, n)

    def capacity(self):
        return _core.MolpherMolVector_capacity(self)
    __swig_destroy__ = _core.delete_MolpherMolVector
    __del__ = lambda self: None
MolpherMolVector_swigregister = _core.MolpherMolVector_swigregister
MolpherMolVector_swigregister(MolpherMolVector)

class MolpherMolMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolpherMolMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MolpherMolMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.MolpherMolMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MolpherMolMap___nonzero__(self)

    def __bool__(self):
        return _core.MolpherMolMap___bool__(self)

    def __len__(self):
        return _core.MolpherMolMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _core.MolpherMolMap___getitem__(self, key)

    def __delitem__(self, key):
        return _core.MolpherMolMap___delitem__(self, key)

    def has_key(self, key):
        return _core.MolpherMolMap_has_key(self, key)

    def keys(self):
        return _core.MolpherMolMap_keys(self)

    def values(self):
        return _core.MolpherMolMap_values(self)

    def items(self):
        return _core.MolpherMolMap_items(self)

    def __contains__(self, key):
        return _core.MolpherMolMap___contains__(self, key)

    def key_iterator(self):
        return _core.MolpherMolMap_key_iterator(self)

    def value_iterator(self):
        return _core.MolpherMolMap_value_iterator(self)

    def __setitem__(self, *args):
        return _core.MolpherMolMap___setitem__(self, *args)

    def asdict(self):
        return _core.MolpherMolMap_asdict(self)

    def __init__(self, *args):
        this = _core.new_MolpherMolMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _core.MolpherMolMap_empty(self)

    def size(self):
        return _core.MolpherMolMap_size(self)

    def swap(self, v):
        return _core.MolpherMolMap_swap(self, v)

    def begin(self):
        return _core.MolpherMolMap_begin(self)

    def end(self):
        return _core.MolpherMolMap_end(self)

    def rbegin(self):
        return _core.MolpherMolMap_rbegin(self)

    def rend(self):
        return _core.MolpherMolMap_rend(self)

    def clear(self):
        return _core.MolpherMolMap_clear(self)

    def get_allocator(self):
        return _core.MolpherMolMap_get_allocator(self)

    def count(self, x):
        return _core.MolpherMolMap_count(self, x)

    def erase(self, *args):
        return _core.MolpherMolMap_erase(self, *args)

    def find(self, x):
        return _core.MolpherMolMap_find(self, x)

    def lower_bound(self, x):
        return _core.MolpherMolMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _core.MolpherMolMap_upper_bound(self, x)
    __swig_destroy__ = _core.delete_MolpherMolMap
    __del__ = lambda self: None
MolpherMolMap_swigregister = _core.MolpherMolMap_swigregister
MolpherMolMap_swigregister(MolpherMolMap)

class MolpherAtomVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolpherAtomVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MolpherAtomVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.MolpherAtomVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MolpherAtomVector___nonzero__(self)

    def __bool__(self):
        return _core.MolpherAtomVector___bool__(self)

    def __len__(self):
        return _core.MolpherAtomVector___len__(self)

    def __getslice__(self, i, j):
        return _core.MolpherAtomVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.MolpherAtomVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.MolpherAtomVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.MolpherAtomVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.MolpherAtomVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.MolpherAtomVector___setitem__(self, *args)

    def pop(self):
        return _core.MolpherAtomVector_pop(self)

    def append(self, x):
        return _core.MolpherAtomVector_append(self, x)

    def empty(self):
        return _core.MolpherAtomVector_empty(self)

    def size(self):
        return _core.MolpherAtomVector_size(self)

    def swap(self, v):
        return _core.MolpherAtomVector_swap(self, v)

    def begin(self):
        return _core.MolpherAtomVector_begin(self)

    def end(self):
        return _core.MolpherAtomVector_end(self)

    def rbegin(self):
        return _core.MolpherAtomVector_rbegin(self)

    def rend(self):
        return _core.MolpherAtomVector_rend(self)

    def clear(self):
        return _core.MolpherAtomVector_clear(self)

    def get_allocator(self):
        return _core.MolpherAtomVector_get_allocator(self)

    def pop_back(self):
        return _core.MolpherAtomVector_pop_back(self)

    def erase(self, *args):
        return _core.MolpherAtomVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_MolpherAtomVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.MolpherAtomVector_push_back(self, x)

    def front(self):
        return _core.MolpherAtomVector_front(self)

    def back(self):
        return _core.MolpherAtomVector_back(self)

    def assign(self, n, x):
        return _core.MolpherAtomVector_assign(self, n, x)

    def resize(self, *args):
        return _core.MolpherAtomVector_resize(self, *args)

    def insert(self, *args):
        return _core.MolpherAtomVector_insert(self, *args)

    def reserve(self, n):
        return _core.MolpherAtomVector_reserve(self, n)

    def capacity(self):
        return _core.MolpherAtomVector_capacity(self)
    __swig_destroy__ = _core.delete_MolpherAtomVector
    __del__ = lambda self: None
MolpherAtomVector_swigregister = _core.MolpherAtomVector_swigregister
MolpherAtomVector_swigregister(MolpherAtomVector)

class MorphingOperatorVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MorphingOperatorVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MorphingOperatorVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.MorphingOperatorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MorphingOperatorVector___nonzero__(self)

    def __bool__(self):
        return _core.MorphingOperatorVector___bool__(self)

    def __len__(self):
        return _core.MorphingOperatorVector___len__(self)

    def __getslice__(self, i, j):
        return _core.MorphingOperatorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.MorphingOperatorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.MorphingOperatorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.MorphingOperatorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.MorphingOperatorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.MorphingOperatorVector___setitem__(self, *args)

    def pop(self):
        return _core.MorphingOperatorVector_pop(self)

    def append(self, x):
        return _core.MorphingOperatorVector_append(self, x)

    def empty(self):
        return _core.MorphingOperatorVector_empty(self)

    def size(self):
        return _core.MorphingOperatorVector_size(self)

    def swap(self, v):
        return _core.MorphingOperatorVector_swap(self, v)

    def begin(self):
        return _core.MorphingOperatorVector_begin(self)

    def end(self):
        return _core.MorphingOperatorVector_end(self)

    def rbegin(self):
        return _core.MorphingOperatorVector_rbegin(self)

    def rend(self):
        return _core.MorphingOperatorVector_rend(self)

    def clear(self):
        return _core.MorphingOperatorVector_clear(self)

    def get_allocator(self):
        return _core.MorphingOperatorVector_get_allocator(self)

    def pop_back(self):
        return _core.MorphingOperatorVector_pop_back(self)

    def erase(self, *args):
        return _core.MorphingOperatorVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_MorphingOperatorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.MorphingOperatorVector_push_back(self, x)

    def front(self):
        return _core.MorphingOperatorVector_front(self)

    def back(self):
        return _core.MorphingOperatorVector_back(self)

    def assign(self, n, x):
        return _core.MorphingOperatorVector_assign(self, n, x)

    def resize(self, *args):
        return _core.MorphingOperatorVector_resize(self, *args)

    def insert(self, *args):
        return _core.MorphingOperatorVector_insert(self, *args)

    def reserve(self, n):
        return _core.MorphingOperatorVector_reserve(self, n)

    def capacity(self):
        return _core.MorphingOperatorVector_capacity(self)
    __swig_destroy__ = _core.delete_MorphingOperatorVector
    __del__ = lambda self: None
MorphingOperatorVector_swigregister = _core.MorphingOperatorVector_swigregister
MorphingOperatorVector_swigregister(MorphingOperatorVector)

class MorphCollectorVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MorphCollectorVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MorphCollectorVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.MorphCollectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MorphCollectorVector___nonzero__(self)

    def __bool__(self):
        return _core.MorphCollectorVector___bool__(self)

    def __len__(self):
        return _core.MorphCollectorVector___len__(self)

    def __getslice__(self, i, j):
        return _core.MorphCollectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.MorphCollectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.MorphCollectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.MorphCollectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.MorphCollectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.MorphCollectorVector___setitem__(self, *args)

    def pop(self):
        return _core.MorphCollectorVector_pop(self)

    def append(self, x):
        return _core.MorphCollectorVector_append(self, x)

    def empty(self):
        return _core.MorphCollectorVector_empty(self)

    def size(self):
        return _core.MorphCollectorVector_size(self)

    def swap(self, v):
        return _core.MorphCollectorVector_swap(self, v)

    def begin(self):
        return _core.MorphCollectorVector_begin(self)

    def end(self):
        return _core.MorphCollectorVector_end(self)

    def rbegin(self):
        return _core.MorphCollectorVector_rbegin(self)

    def rend(self):
        return _core.MorphCollectorVector_rend(self)

    def clear(self):
        return _core.MorphCollectorVector_clear(self)

    def get_allocator(self):
        return _core.MorphCollectorVector_get_allocator(self)

    def pop_back(self):
        return _core.MorphCollectorVector_pop_back(self)

    def erase(self, *args):
        return _core.MorphCollectorVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_MorphCollectorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _core.MorphCollectorVector_push_back(self, x)

    def front(self):
        return _core.MorphCollectorVector_front(self)

    def back(self):
        return _core.MorphCollectorVector_back(self)

    def assign(self, n, x):
        return _core.MorphCollectorVector_assign(self, n, x)

    def resize(self, *args):
        return _core.MorphCollectorVector_resize(self, *args)

    def insert(self, *args):
        return _core.MorphCollectorVector_insert(self, *args)

    def reserve(self, n):
        return _core.MorphCollectorVector_reserve(self, n)

    def capacity(self):
        return _core.MorphCollectorVector_capacity(self)
    __swig_destroy__ = _core.delete_MorphCollectorVector
    __del__ = lambda self: None
MorphCollectorVector_swigregister = _core.MorphCollectorVector_swigregister
MorphCollectorVector_swigregister(MorphCollectorVector)

class MolpherAtom(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolpherAtom, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MolpherAtom, name)
    __repr__ = _swig_repr
    UNLOCKED = _core.MolpherAtom_UNLOCKED
    NO_MUTATION = _core.MolpherAtom_NO_MUTATION
    NO_ADDITION = _core.MolpherAtom_NO_ADDITION
    NO_REMOVAL = _core.MolpherAtom_NO_REMOVAL
    KEEP_NEIGHBORS = _core.MolpherAtom_KEEP_NEIGHBORS
    KEEP_NEIGHBORS_AND_BONDS = _core.MolpherAtom_KEEP_NEIGHBORS_AND_BONDS
    KEEP_BONDS = _core.MolpherAtom_KEEP_BONDS
    FULL_LOCK = _core.MolpherAtom_FULL_LOCK
    if _newclass:
        lockToString = staticmethod(_core.MolpherAtom_lockToString)
    else:
        lockToString = _core.MolpherAtom_lockToString
    if _newclass:
        lockingMaskToString = staticmethod(_core.MolpherAtom_lockingMaskToString)
    else:
        lockingMaskToString = _core.MolpherAtom_lockingMaskToString

    def __init__(self, *args):
        this = _core.new_MolpherAtom(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_MolpherAtom
    __del__ = lambda self: None

    def isLocked(self):
        return _core.MolpherAtom_isLocked(self)

    def getLockingMask(self):
        return _core.MolpherAtom_getLockingMask(self)

    def getAtomicNum(self):
        return _core.MolpherAtom_getAtomicNum(self)

    def getMass(self):
        return _core.MolpherAtom_getMass(self)

    def getFormalCharge(self):
        return _core.MolpherAtom_getFormalCharge(self)

    def getSymbol(self):
        return _core.MolpherAtom_getSymbol(self)

    def setLockingMask(self, mask):
        return _core.MolpherAtom_setLockingMask(self, mask)

    def setFormalCharge(self, charge):
        return _core.MolpherAtom_setFormalCharge(self, charge)
MolpherAtom_swigregister = _core.MolpherAtom_swigregister
MolpherAtom_swigregister(MolpherAtom)
cvar = _core.cvar
MolpherAtom.atom_locks = _core.cvar.MolpherAtom_atom_locks

def MolpherAtom_lockToString(lock):
    return _core.MolpherAtom_lockToString(lock)
MolpherAtom_lockToString = _core.MolpherAtom_lockToString

def MolpherAtom_lockingMaskToString(mask):
    return _core.MolpherAtom_lockingMaskToString(mask)
MolpherAtom_lockingMaskToString = _core.MolpherAtom_lockingMaskToString

class MolpherMol(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolpherMol, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MolpherMol, name)
    __repr__ = _swig_repr
    if _newclass:
        fromMolBlock = staticmethod(_core.MolpherMol_fromMolBlock)
    else:
        fromMolBlock = _core.MolpherMol_fromMolBlock

    def __init__(self, *args):
        this = _core.new_MolpherMol(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_MolpherMol
    __del__ = lambda self: None

    def copy(self):
        return _core.MolpherMol_copy(self)

    def asMolBlock(self, include_locks=False):
        return _core.MolpherMol_asMolBlock(self, include_locks)

    def lockAtom(self, idx, mask):
        return _core.MolpherMol_lockAtom(self, idx, mask)

    def getAtom(self, idx):
        return _core.MolpherMol_getAtom(self, idx)

    def getAtoms(self):
        return _core.MolpherMol_getAtoms(self)

    def getNeighbors(self, idx):
        return _core.MolpherMol_getNeighbors(self, idx)

    def getAtomCount(self):
        return _core.MolpherMol_getAtomCount(self)

    def lockAtoms(self, *args):
        return _core.MolpherMol_lockAtoms(self, *args)

    def getSMILES(self):
        return _core.MolpherMol_getSMILES(self)

    def getDistToTarget(self):
        return _core.MolpherMol_getDistToTarget(self)

    def getTree(self):
        return _core.MolpherMol_getTree(self)

    def getParentSMILES(self):
        return _core.MolpherMol_getParentSMILES(self)

    def getDescendants(self):
        return _core.MolpherMol_getDescendants(self)

    def getHistoricDescendants(self):
        return _core.MolpherMol_getHistoricDescendants(self)

    def getItersWithoutDistImprovement(self):
        return _core.MolpherMol_getItersWithoutDistImprovement(self)

    def getSAScore(self):
        return _core.MolpherMol_getSAScore(self)

    def getMolecularWeight(self):
        return _core.MolpherMol_getMolecularWeight(self)

    def getFormula(self):
        return _core.MolpherMol_getFormula(self)

    def getParentOper(self):
        return _core.MolpherMol_getParentOper(self)

    def setOwner(self, tree):
        return _core.MolpherMol_setOwner(self, tree)

    def setSMILES(self, arg2):
        return _core.MolpherMol_setSMILES(self, arg2)

    def setParentSMILES(self, arg2):
        return _core.MolpherMol_setParentSMILES(self, arg2)

    def setParentOper(self, arg2):
        return _core.MolpherMol_setParentOper(self, arg2)

    def setDistToTarget(self, dist):
        return _core.MolpherMol_setDistToTarget(self, dist)

    def setSAScore(self, score):
        return _core.MolpherMol_setSAScore(self, score)

    def setItersWithoutDistImprovement(self, count):
        return _core.MolpherMol_setItersWithoutDistImprovement(self, count)

    def increaseItersWithoutDistImprovement(self):
        return _core.MolpherMol_increaseItersWithoutDistImprovement(self)

    def decreaseItersWithoutDistImprovement(self):
        return _core.MolpherMol_decreaseItersWithoutDistImprovement(self)

    def addToDescendants(self, smiles):
        return _core.MolpherMol_addToDescendants(self, smiles)

    def removeFromDescendants(self, smiles):
        return _core.MolpherMol_removeFromDescendants(self, smiles)

    def setDescendants(self, arg2):
        return _core.MolpherMol_setDescendants(self, arg2)

    def addToHistoricDescendants(self, smiles):
        return _core.MolpherMol_addToHistoricDescendants(self, smiles)

    def removeFromHistoricDescendants(self, smiles):
        return _core.MolpherMol_removeFromHistoricDescendants(self, smiles)

    def setHistoricDescendants(self, arg2):
        return _core.MolpherMol_setHistoricDescendants(self, arg2)

    def isValid(self):
        return _core.MolpherMol_isValid(self)

    def isBoundToTree(self):
        return _core.MolpherMol_isBoundToTree(self)

    def removeFromTree(self):
        return _core.MolpherMol_removeFromTree(self)
MolpherMol_swigregister = _core.MolpherMol_swigregister
MolpherMol_swigregister(MolpherMol)

def MolpherMol_fromMolBlock(mol_block):
    return _core.MolpherMol_fromMolBlock(mol_block)
MolpherMol_fromMolBlock = _core.MolpherMol_fromMolBlock

class ExplorationData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExplorationData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExplorationData, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_ExplorationData()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_ExplorationData
    __del__ = lambda self: None

    def getGenerationCount(self):
        return _core.ExplorationData_getGenerationCount(self)

    def getThreadCount(self):
        return _core.ExplorationData_getThreadCount(self)

    def getFingerprint(self):
        return _core.ExplorationData_getFingerprint(self)

    def getSimilarityCoefficient(self):
        return _core.ExplorationData_getSimilarityCoefficient(self)

    def getChemicalOperators(self):
        return _core.ExplorationData_getChemicalOperators(self)

    def getMinAcceptableMolecularWeight(self):
        return _core.ExplorationData_getMinAcceptableMolecularWeight(self)

    def getMaxAcceptableMolecularWeight(self):
        return _core.ExplorationData_getMaxAcceptableMolecularWeight(self)

    def getCntCandidatesToKeep(self):
        return _core.ExplorationData_getCntCandidatesToKeep(self)

    def getCntCandidatesToKeepMax(self):
        return _core.ExplorationData_getCntCandidatesToKeepMax(self)

    def getCntMorphs(self):
        return _core.ExplorationData_getCntMorphs(self)

    def getCntMorphsInDepth(self):
        return _core.ExplorationData_getCntMorphsInDepth(self)

    def getDistToTargetDepthSwitch(self):
        return _core.ExplorationData_getDistToTargetDepthSwitch(self)

    def getCntMaxMorphs(self):
        return _core.ExplorationData_getCntMaxMorphs(self)

    def getItThreshold(self):
        return _core.ExplorationData_getItThreshold(self)

    def getSource(self):
        return _core.ExplorationData_getSource(self)

    def getTarget(self):
        return _core.ExplorationData_getTarget(self)

    def getCandidates(self):
        return _core.ExplorationData_getCandidates(self)

    def getCandidatesMask(self):
        return _core.ExplorationData_getCandidatesMask(self)

    def getTreeMap(self):
        return _core.ExplorationData_getTreeMap(self)

    def getDerivationMap(self):
        return _core.ExplorationData_getDerivationMap(self)

    def setGenerationCount(self, arg2):
        return _core.ExplorationData_setGenerationCount(self, arg2)

    def setThreadCount(self, arg2):
        return _core.ExplorationData_setThreadCount(self, arg2)

    def setFingerprint(self, arg2):
        return _core.ExplorationData_setFingerprint(self, arg2)

    def setSimilarityCoefficient(self, arg2):
        return _core.ExplorationData_setSimilarityCoefficient(self, arg2)

    def setChemicalOperators(self, arg2):
        return _core.ExplorationData_setChemicalOperators(self, arg2)

    def addChemicalOperator(self, arg2):
        return _core.ExplorationData_addChemicalOperator(self, arg2)

    def removeChemicalOperator(self, arg2):
        return _core.ExplorationData_removeChemicalOperator(self, arg2)

    def setMinAcceptableMolecularWeight(self, arg2):
        return _core.ExplorationData_setMinAcceptableMolecularWeight(self, arg2)

    def setMaxAcceptableMolecularWeight(self, arg2):
        return _core.ExplorationData_setMaxAcceptableMolecularWeight(self, arg2)

    def setCntCandidatesToKeep(self, arg2):
        return _core.ExplorationData_setCntCandidatesToKeep(self, arg2)

    def setCntCandidatesToKeepMax(self, arg2):
        return _core.ExplorationData_setCntCandidatesToKeepMax(self, arg2)

    def setCntMorphs(self, arg2):
        return _core.ExplorationData_setCntMorphs(self, arg2)

    def setCntMorphsInDepth(self, arg2):
        return _core.ExplorationData_setCntMorphsInDepth(self, arg2)

    def setDistToTargetDepthSwitch(self, arg2):
        return _core.ExplorationData_setDistToTargetDepthSwitch(self, arg2)

    def setCntMaxMorphs(self, arg2):
        return _core.ExplorationData_setCntMaxMorphs(self, arg2)

    def setItThreshold(self, arg2):
        return _core.ExplorationData_setItThreshold(self, arg2)

    def setSource(self, arg2):
        return _core.ExplorationData_setSource(self, arg2)

    def setTarget(self, arg2):
        return _core.ExplorationData_setTarget(self, arg2)

    def setCandidates(self, arg2):
        return _core.ExplorationData_setCandidates(self, arg2)

    def addCandidate(self, *args):
        return _core.ExplorationData_addCandidate(self, *args)

    def removeCandidate(self, index):
        return _core.ExplorationData_removeCandidate(self, index)

    def setCandidatesMask(self, arg2):
        return _core.ExplorationData_setCandidatesMask(self, arg2)

    def setCandidatesMaskAt(self, arg2, arg3):
        return _core.ExplorationData_setCandidatesMaskAt(self, arg2, arg3)

    def addToTreeMap(self, arg2, arg3):
        return _core.ExplorationData_addToTreeMap(self, arg2, arg3)

    def popFromTreeMap(self, arg2):
        return _core.ExplorationData_popFromTreeMap(self, arg2)

    def addToDerivationMap(self, arg2, arg3):
        return _core.ExplorationData_addToDerivationMap(self, arg2, arg3)

    def increaseDerivationsCount(self, arg2):
        return _core.ExplorationData_increaseDerivationsCount(self, arg2)

    def decreaseDerivationsCount(self, arg2):
        return _core.ExplorationData_decreaseDerivationsCount(self, arg2)

    def popFromDerivationMap(self, arg2):
        return _core.ExplorationData_popFromDerivationMap(self, arg2)
    if _newclass:
        load = staticmethod(_core.ExplorationData_load)
    else:
        load = _core.ExplorationData_load

    def save(self, file):
        return _core.ExplorationData_save(self, file)

    def isValid(self):
        return _core.ExplorationData_isValid(self)
ExplorationData_swigregister = _core.ExplorationData_swigregister
ExplorationData_swigregister(ExplorationData)

def ExplorationData_load(file):
    return _core.ExplorationData_load(file)
ExplorationData_load = _core.ExplorationData_load

class ExplorationTree(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExplorationTree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExplorationTree, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    if _newclass:
        create = staticmethod(_core.ExplorationTree_create)
    else:
        create = _core.ExplorationTree_create

    def asData(self):
        return _core.ExplorationTree_asData(self)

    def update(self, data):
        return _core.ExplorationTree_update(self, data)

    def getMorphingOperators(self):
        return _core.ExplorationTree_getMorphingOperators(self)

    def setMorphingOperators(self, operators):
        return _core.ExplorationTree_setMorphingOperators(self, operators)

    def addMorphingOperator(self, operator_):
        return _core.ExplorationTree_addMorphingOperator(self, operator_)

    def runOperation(self, operation):
        return _core.ExplorationTree_runOperation(self, operation)

    def fetchLeaves(self, increase_dist_improve_counter=False):
        return _core.ExplorationTree_fetchLeaves(self, increase_dist_improve_counter)

    def fetchMol(self, canonSMILES):
        return _core.ExplorationTree_fetchMol(self, canonSMILES)

    def hasMol(self, *args):
        return _core.ExplorationTree_hasMol(self, *args)

    def isPathFound(self):
        return _core.ExplorationTree_isPathFound(self)

    def deleteSubtree(self, canonSMILES, descendents_only=False):
        return _core.ExplorationTree_deleteSubtree(self, canonSMILES, descendents_only)

    def generateMorphs(self, *args):
        return _core.ExplorationTree_generateMorphs(self, *args)

    def sortMorphs(self):
        return _core.ExplorationTree_sortMorphs(self)

    def filterMorphs(self, *args):
        return _core.ExplorationTree_filterMorphs(self, *args)

    def extend(self):
        return _core.ExplorationTree_extend(self)

    def prune(self):
        return _core.ExplorationTree_prune(self)

    def traverse(self, *args):
        return _core.ExplorationTree_traverse(self, *args)

    def save(self, filename):
        return _core.ExplorationTree_save(self, filename)

    def getThreadCount(self):
        return _core.ExplorationTree_getThreadCount(self)

    def getGenerationCount(self):
        return _core.ExplorationTree_getGenerationCount(self)

    def getCandidateMorphs(self):
        return _core.ExplorationTree_getCandidateMorphs(self)

    def getCandidateMorphsMask(self):
        return _core.ExplorationTree_getCandidateMorphsMask(self)

    def setThreadCount(self, threadCnt):
        return _core.ExplorationTree_setThreadCount(self, threadCnt)

    def setCandidateMorphsMask(self, arg2):
        return _core.ExplorationTree_setCandidateMorphsMask(self, arg2)
    __swig_destroy__ = _core.delete_ExplorationTree
    __del__ = lambda self: None
ExplorationTree_swigregister = _core.ExplorationTree_swigregister
ExplorationTree_swigregister(ExplorationTree)

def ExplorationTree_create(*args):
    return _core.ExplorationTree_create(*args)
ExplorationTree_create = _core.ExplorationTree_create

class TreeOperation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TreeOperation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TreeOperation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        if self.__class__ == TreeOperation:
            _self = None
        else:
            _self = self
        this = _core.new_TreeOperation(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_TreeOperation
    __del__ = lambda self: None

    def __call__(self):
        return _core.TreeOperation___call__(self)

    def getTree(self):
        return _core.TreeOperation_getTree(self)

    def setTree(self, tree):
        return _core.TreeOperation_setTree(self, tree)
    def __disown__(self):
        self.this.disown()
        _core.disown_TreeOperation(self)
        return weakref_proxy(self)
TreeOperation_swigregister = _core.TreeOperation_swigregister
TreeOperation_swigregister(TreeOperation)

class FindLeavesOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FindLeavesOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FindLeavesOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_FindLeavesOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.FindLeavesOper___call__(self)

    def fetchLeaves(self):
        return _core.FindLeavesOper_fetchLeaves(self)
    __swig_destroy__ = _core.delete_FindLeavesOper
    __del__ = lambda self: None
FindLeavesOper_swigregister = _core.FindLeavesOper_swigregister
FindLeavesOper_swigregister(FindLeavesOper)

class GenerateMorphsOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenerateMorphsOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenerateMorphsOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_GenerateMorphsOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.GenerateMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_GenerateMorphsOper
    __del__ = lambda self: None
GenerateMorphsOper_swigregister = _core.GenerateMorphsOper_swigregister
GenerateMorphsOper_swigregister(GenerateMorphsOper)

class SortMorphsOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SortMorphsOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SortMorphsOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_SortMorphsOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.SortMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_SortMorphsOper
    __del__ = lambda self: None
SortMorphsOper_swigregister = _core.SortMorphsOper_swigregister
SortMorphsOper_swigregister(SortMorphsOper)

class FilterMorphsOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilterMorphsOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilterMorphsOper, name)
    __repr__ = _swig_repr
    PROBABILITY = _core.FilterMorphsOper_PROBABILITY
    WEIGHT = _core.FilterMorphsOper_WEIGHT
    SYNTHESIS = _core.FilterMorphsOper_SYNTHESIS
    MAX_DERIVATIONS = _core.FilterMorphsOper_MAX_DERIVATIONS
    DUPLICATES = _core.FilterMorphsOper_DUPLICATES
    HISTORIC_DESCENDENTS = _core.FilterMorphsOper_HISTORIC_DESCENDENTS
    ALL = _core.FilterMorphsOper_ALL

    def __init__(self, *args):
        this = _core.new_FilterMorphsOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.FilterMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_FilterMorphsOper
    __del__ = lambda self: None
FilterMorphsOper_swigregister = _core.FilterMorphsOper_swigregister
FilterMorphsOper_swigregister(FilterMorphsOper)

class ExtendTreeOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExtendTreeOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExtendTreeOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_ExtendTreeOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.ExtendTreeOper___call__(self)
    __swig_destroy__ = _core.delete_ExtendTreeOper
    __del__ = lambda self: None
ExtendTreeOper_swigregister = _core.ExtendTreeOper_swigregister
ExtendTreeOper_swigregister(ExtendTreeOper)

class PruneTreeOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PruneTreeOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PruneTreeOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_PruneTreeOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.PruneTreeOper___call__(self)
    __swig_destroy__ = _core.delete_PruneTreeOper
    __del__ = lambda self: None
PruneTreeOper_swigregister = _core.PruneTreeOper_swigregister
PruneTreeOper_swigregister(PruneTreeOper)

class TraverseOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraverseOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TraverseOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_TraverseOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.TraverseOper___call__(self)
    __swig_destroy__ = _core.delete_TraverseOper
    __del__ = lambda self: None
TraverseOper_swigregister = _core.TraverseOper_swigregister
TraverseOper_swigregister(TraverseOper)

class CleanMorphsOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CleanMorphsOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CleanMorphsOper, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_CleanMorphsOper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _core.CleanMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_CleanMorphsOper
    __del__ = lambda self: None
CleanMorphsOper_swigregister = _core.CleanMorphsOper_swigregister
CleanMorphsOper_swigregister(CleanMorphsOper)

class TraverseCallback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraverseCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TraverseCallback, name)
    __repr__ = _swig_repr

    def __init__(self):
        if self.__class__ == TraverseCallback:
            _self = None
        else:
            _self = self
        this = _core.new_TraverseCallback(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_TraverseCallback
    __del__ = lambda self: None

    def __call__(self, morph):
        return _core.TraverseCallback___call__(self, morph)
    def __disown__(self):
        self.this.disown()
        _core.disown_TraverseCallback(self)
        return weakref_proxy(self)
TraverseCallback_swigregister = _core.TraverseCallback_swigregister
TraverseCallback_swigregister(TraverseCallback)

class SortMorphsCallback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SortMorphsCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SortMorphsCallback, name)
    __repr__ = _swig_repr

    def __init__(self):
        if self.__class__ == SortMorphsCallback:
            _self = None
        else:
            _self = self
        this = _core.new_SortMorphsCallback(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_SortMorphsCallback
    __del__ = lambda self: None

    def __call__(self, morph_1, morph_2):
        return _core.SortMorphsCallback___call__(self, morph_1, morph_2)
    def __disown__(self):
        self.this.disown()
        _core.disown_SortMorphsCallback(self)
        return weakref_proxy(self)
SortMorphsCallback_swigregister = _core.SortMorphsCallback_swigregister
SortMorphsCallback_swigregister(SortMorphsCallback)

class DefaultSortCallback(SortMorphsCallback):
    __swig_setmethods__ = {}
    for _s in [SortMorphsCallback]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DefaultSortCallback, name, value)
    __swig_getmethods__ = {}
    for _s in [SortMorphsCallback]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DefaultSortCallback, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_DefaultSortCallback()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, morph_1, morph_2):
        return _core.DefaultSortCallback___call__(self, morph_1, morph_2)
    __swig_destroy__ = _core.delete_DefaultSortCallback
    __del__ = lambda self: None
DefaultSortCallback_swigregister = _core.DefaultSortCallback_swigregister
DefaultSortCallback_swigregister(DefaultSortCallback)

OP_ADD_ATOM = _core.OP_ADD_ATOM
OP_REMOVE_ATOM = _core.OP_REMOVE_ATOM
OP_ADD_BOND = _core.OP_ADD_BOND
OP_REMOVE_BOND = _core.OP_REMOVE_BOND
OP_MUTATE_ATOM = _core.OP_MUTATE_ATOM
OP_INTERLAY_ATOM = _core.OP_INTERLAY_ATOM
OP_BOND_REROUTE = _core.OP_BOND_REROUTE
OP_BOND_CONTRACTION = _core.OP_BOND_CONTRACTION

def ChemOperShortDesc(selector):
    return _core.ChemOperShortDesc(selector)
ChemOperShortDesc = _core.ChemOperShortDesc

def ChemOperLongDesc(selector):
    return _core.ChemOperLongDesc(selector)
ChemOperLongDesc = _core.ChemOperLongDesc
FP_ATOM_PAIRS = _core.FP_ATOM_PAIRS
FP_MORGAN = _core.FP_MORGAN
FP_TOPOLOGICAL = _core.FP_TOPOLOGICAL
FP_TOPOLOGICAL_LAYERED_1 = _core.FP_TOPOLOGICAL_LAYERED_1
FP_TOPOLOGICAL_LAYERED_2 = _core.FP_TOPOLOGICAL_LAYERED_2
FP_VECTORFP = _core.FP_VECTORFP
FP_TOPOLOGICAL_TORSION = _core.FP_TOPOLOGICAL_TORSION
FP_EXT_ATOM_PAIRS = _core.FP_EXT_ATOM_PAIRS
FP_EXT_MORGAN = _core.FP_EXT_MORGAN
FP_EXT_TOPOLOGICAL = _core.FP_EXT_TOPOLOGICAL
FP_EXT_TOPOLOGICAL_LAYERED_1 = _core.FP_EXT_TOPOLOGICAL_LAYERED_1
FP_EXT_TOPOLOGICAL_LAYERED_2 = _core.FP_EXT_TOPOLOGICAL_LAYERED_2
FP_EXT_TOPOLOGICAL_TORSION = _core.FP_EXT_TOPOLOGICAL_TORSION

def FingerprintShortDesc(selector):
    return _core.FingerprintShortDesc(selector)
FingerprintShortDesc = _core.FingerprintShortDesc

def FingerprintLongDesc(selector):
    return _core.FingerprintLongDesc(selector)
FingerprintLongDesc = _core.FingerprintLongDesc

def FingerprintParse(name):
    return _core.FingerprintParse(name)
FingerprintParse = _core.FingerprintParse
SC_ALL_BIT = _core.SC_ALL_BIT
SC_ASYMMETRIC = _core.SC_ASYMMETRIC
SC_BRAUN_BLANQUET = _core.SC_BRAUN_BLANQUET
SC_COSINE = _core.SC_COSINE
SC_DICE = _core.SC_DICE
SC_KULCZYNSKI = _core.SC_KULCZYNSKI
SC_MC_CONNAUGHEY = _core.SC_MC_CONNAUGHEY
SC_ON_BIT = _core.SC_ON_BIT
SC_RUSSEL = _core.SC_RUSSEL
SC_SOKAL = _core.SC_SOKAL
SC_TANIMOTO = _core.SC_TANIMOTO
SC_TVERSKY_SUBSTRUCTURE = _core.SC_TVERSKY_SUBSTRUCTURE
SC_TVERSKY_SUPERSTRUCTURE = _core.SC_TVERSKY_SUPERSTRUCTURE

def SimCoeffShortDesc(selector):
    return _core.SimCoeffShortDesc(selector)
SimCoeffShortDesc = _core.SimCoeffShortDesc

def SimCoeffLongDesc(selector):
    return _core.SimCoeffLongDesc(selector)
SimCoeffLongDesc = _core.SimCoeffLongDesc

def SimCoeffParse(name):
    return _core.SimCoeffParse(name)
SimCoeffParse = _core.SimCoeffParse
class AtomLibrary(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomLibrary, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomLibrary, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_AtomLibrary(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_AtomLibrary
    __del__ = lambda self: None
    if _newclass:
        getDefaultLibrary = staticmethod(_core.AtomLibrary_getDefaultLibrary)
    else:
        getDefaultLibrary = _core.AtomLibrary_getDefaultLibrary
    if _newclass:
        setDefaultLibrary = staticmethod(_core.AtomLibrary_setDefaultLibrary)
    else:
        setDefaultLibrary = _core.AtomLibrary_setDefaultLibrary

    def getRandomAtom(self):
        return _core.AtomLibrary_getRandomAtom(self)

    def getAtoms(self):
        return _core.AtomLibrary_getAtoms(self)
AtomLibrary_swigregister = _core.AtomLibrary_swigregister
AtomLibrary_swigregister(AtomLibrary)

def AtomLibrary_getDefaultLibrary():
    return _core.AtomLibrary_getDefaultLibrary()
AtomLibrary_getDefaultLibrary = _core.AtomLibrary_getDefaultLibrary

def AtomLibrary_setDefaultLibrary(new_default):
    return _core.AtomLibrary_setDefaultLibrary(new_default)
AtomLibrary_setDefaultLibrary = _core.AtomLibrary_setDefaultLibrary

class Molpher(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Molpher, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Molpher, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_Molpher(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_Molpher
    __del__ = lambda self: None

    def __call__(self):
        return _core.Molpher___call__(self)

    def getMorphs(self):
        return _core.Molpher_getMorphs(self)

    def getOriginal(self):
        return _core.Molpher_getOriginal(self)

    def reset(self, original):
        return _core.Molpher_reset(self, original)
Molpher_swigregister = _core.Molpher_swigregister
Molpher_swigregister(Molpher)

class MorphCollector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MorphCollector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MorphCollector, name)
    __repr__ = _swig_repr

    def __init__(self):
        if self.__class__ == MorphCollector:
            _self = None
        else:
            _self = self
        this = _core.new_MorphCollector(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_MorphCollector
    __del__ = lambda self: None

    def __call__(self, morph, operator_):
        return _core.MorphCollector___call__(self, morph, operator_)
    def __disown__(self):
        self.this.disown()
        _core.disown_MorphCollector(self)
        return weakref_proxy(self)
MorphCollector_swigregister = _core.MorphCollector_swigregister
MorphCollector_swigregister(MorphCollector)

class MorphingOperator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MorphingOperator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MorphingOperator, name)
    __repr__ = _swig_repr

    def __init__(self):
        if self.__class__ == MorphingOperator:
            _self = None
        else:
            _self = self
        this = _core.new_MorphingOperator(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _core.delete_MorphingOperator
    __del__ = lambda self: None

    def getOriginal(self):
        return _core.MorphingOperator_getOriginal(self)

    def setOriginal(self, arg0):
        return _core.MorphingOperator_setOriginal(self, arg0)

    def morph(self):
        return _core.MorphingOperator_morph(self)

    def getName(self):
        return _core.MorphingOperator_getName(self)
    def __disown__(self):
        self.this.disown()
        _core.disown_MorphingOperator(self)
        return weakref_proxy(self)
MorphingOperator_swigregister = _core.MorphingOperator_swigregister
MorphingOperator_swigregister(MorphingOperator)

class AddAtom(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AddAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AddAtom, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_AddAtom(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.AddAtom_setOriginal(self, mol)

    def morph(self):
        return _core.AddAtom_morph(self)

    def getName(self):
        return _core.AddAtom_getName(self)

    def getOpenIndices(self):
        return _core.AddAtom_getOpenIndices(self)

    def getOpenAtoms(self):
        return _core.AddAtom_getOpenAtoms(self)
    __swig_destroy__ = _core.delete_AddAtom
    __del__ = lambda self: None
AddAtom_swigregister = _core.AddAtom_swigregister
AddAtom_swigregister(AddAtom)

class RemoveAtom(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RemoveAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RemoveAtom, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_RemoveAtom()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.RemoveAtom_setOriginal(self, mol)

    def morph(self):
        return _core.RemoveAtom_morph(self)

    def getName(self):
        return _core.RemoveAtom_getName(self)

    def getMarkedIndices(self):
        return _core.RemoveAtom_getMarkedIndices(self)

    def getMarkedAtoms(self):
        return _core.RemoveAtom_getMarkedAtoms(self)
    __swig_destroy__ = _core.delete_RemoveAtom
    __del__ = lambda self: None
RemoveAtom_swigregister = _core.RemoveAtom_swigregister
RemoveAtom_swigregister(RemoveAtom)

class MutateAtom(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MutateAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MutateAtom, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_MutateAtom(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.MutateAtom_setOriginal(self, mol)

    def morph(self):
        return _core.MutateAtom_morph(self)

    def getName(self):
        return _core.MutateAtom_getName(self)
    __swig_destroy__ = _core.delete_MutateAtom
    __del__ = lambda self: None
MutateAtom_swigregister = _core.MutateAtom_swigregister
MutateAtom_swigregister(MutateAtom)

class AddBond(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AddBond, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AddBond, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_AddBond()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.AddBond_setOriginal(self, mol)

    def morph(self):
        return _core.AddBond_morph(self)

    def getName(self):
        return _core.AddBond_getName(self)

    def getOpenBonds(self):
        return _core.AddBond_getOpenBonds(self)
    __swig_destroy__ = _core.delete_AddBond
    __del__ = lambda self: None
AddBond_swigregister = _core.AddBond_swigregister
AddBond_swigregister(AddBond)

class RemoveBond(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RemoveBond, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RemoveBond, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_RemoveBond()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.RemoveBond_setOriginal(self, mol)

    def morph(self):
        return _core.RemoveBond_morph(self)

    def getName(self):
        return _core.RemoveBond_getName(self)

    def getOpenBonds(self):
        return _core.RemoveBond_getOpenBonds(self)
    __swig_destroy__ = _core.delete_RemoveBond
    __del__ = lambda self: None
RemoveBond_swigregister = _core.RemoveBond_swigregister
RemoveBond_swigregister(RemoveBond)

class ContractBond(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ContractBond, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ContractBond, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_ContractBond()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.ContractBond_setOriginal(self, mol)

    def morph(self):
        return _core.ContractBond_morph(self)

    def getName(self):
        return _core.ContractBond_getName(self)

    def getOpenBonds(self):
        return _core.ContractBond_getOpenBonds(self)
    __swig_destroy__ = _core.delete_ContractBond
    __del__ = lambda self: None
ContractBond_swigregister = _core.ContractBond_swigregister
ContractBond_swigregister(ContractBond)

class InterlayAtom(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InterlayAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InterlayAtom, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _core.new_InterlayAtom(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.InterlayAtom_setOriginal(self, mol)

    def morph(self):
        return _core.InterlayAtom_morph(self)

    def getName(self):
        return _core.InterlayAtom_getName(self)
    __swig_destroy__ = _core.delete_InterlayAtom
    __del__ = lambda self: None
InterlayAtom_swigregister = _core.InterlayAtom_swigregister
InterlayAtom_swigregister(InterlayAtom)

class RerouteBond(MorphingOperator):
    __swig_setmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RerouteBond, name, value)
    __swig_getmethods__ = {}
    for _s in [MorphingOperator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RerouteBond, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _core.new_RerouteBond()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setOriginal(self, mol):
        return _core.RerouteBond_setOriginal(self, mol)

    def morph(self):
        return _core.RerouteBond_morph(self)

    def getName(self):
        return _core.RerouteBond_getName(self)
    __swig_destroy__ = _core.delete_RerouteBond
    __del__ = lambda self: None
RerouteBond_swigregister = _core.RerouteBond_swigregister
RerouteBond_swigregister(RerouteBond)

# This file is compatible with both classic and new-style classes.