domino/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.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
if 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('_IMP_domino', [dirname(__file__)])
        except ImportError:
            import _IMP_domino
            return _IMP_domino
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_domino', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_domino = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_domino
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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):
        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(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


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


class IMP_DOMINO_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_DOMINO_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_DOMINO_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_DOMINO_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete_IMP_DOMINO_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_DOMINO_SwigPyIterator self, size_t n=1) -> IMP_DOMINO_SwigPyIterator
        incr(IMP_DOMINO_SwigPyIterator self) -> IMP_DOMINO_SwigPyIterator
        """
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_DOMINO_SwigPyIterator self, size_t n=1) -> IMP_DOMINO_SwigPyIterator
        decr(IMP_DOMINO_SwigPyIterator self) -> IMP_DOMINO_SwigPyIterator
        """
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> bool"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_DOMINO_SwigPyIterator self) -> IMP_DOMINO_SwigPyIterator"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> bool"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> bool"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_DOMINO_SwigPyIterator self, ptrdiff_t n) -> IMP_DOMINO_SwigPyIterator
        __sub__(IMP_DOMINO_SwigPyIterator self, IMP_DOMINO_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_domino.IMP_DOMINO_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_DOMINO_SwigPyIterator_swigregister = _IMP_domino.IMP_DOMINO_SwigPyIterator_swigregister
IMP_DOMINO_SwigPyIterator_swigregister(IMP_DOMINO_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]

IMP_DEBUG = _IMP_domino.IMP_DEBUG
IMP_RELEASE = _IMP_domino.IMP_RELEASE
IMP_SILENT = _IMP_domino.IMP_SILENT
IMP_PROGRESS = _IMP_domino.IMP_PROGRESS
IMP_TERSE = _IMP_domino.IMP_TERSE
IMP_VERBOSE = _IMP_domino.IMP_VERBOSE
IMP_MEMORY = _IMP_domino.IMP_MEMORY
IMP_NONE = _IMP_domino.IMP_NONE
IMP_USAGE = _IMP_domino.IMP_USAGE
IMP_INTERNAL = _IMP_domino.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_domino.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_domino.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_domino.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_domino.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_domino.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_domino.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_domino.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_domino.IMPBASE_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        
        
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

DEFAULT_CHECK = _IMP_domino.DEFAULT_CHECK
NONE = _IMP_domino.NONE
USAGE = _IMP_domino.USAGE
USAGE_AND_INTERNAL = _IMP_domino.USAGE_AND_INTERNAL

def set_check_level(*args):
  """set_check_level(IMP::base::CheckLevel tf)"""
  return _IMP_domino.set_check_level(*args)

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_domino.get_check_level()
class _ostream(_object):
    """Proxy of C++ std::ostream class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_domino._ostream_write(self, *args)

_ostream_swigregister = _IMP_domino._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_domino.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_domino.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_domino.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_domino.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_domino.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_domino.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_domino.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_domino.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_domino.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_domino.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_domino.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_domino.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_domino.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_domino.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_domino.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_domino.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_domino.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_domino.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_domino.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_domino.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_domino.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_domino.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_CGAL
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_HDF5
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_domino.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_STATISTICS_HAS_IMP_BASE = _IMP_domino.IMP_STATISTICS_HAS_IMP_BASE
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_domino.IMP_STATISTICS_HAS_IMP_CGAL
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_domino.IMP_STATISTICS_HAS_BOOST_RANDOM
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_domino.IMP_STATISTICS_HAS_BOOST_SYSTEM
IMP_STATISTICS_HAS_CGAL = _IMP_domino.IMP_STATISTICS_HAS_CGAL
IMPSTATISTICS_SHOW_WARNINGS = _IMP_domino.IMPSTATISTICS_SHOW_WARNINGS
import IMP.statistics
IMP_CORE_HAS_IMP_BASE = _IMP_domino.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_domino.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_domino.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_domino.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_domino.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_domino.IMP_CORE_HAS_CGAL
IMP_CORE_HAS_HDF5 = _IMP_domino.IMP_CORE_HAS_HDF5
IMPCORE_SHOW_WARNINGS = _IMP_domino.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_domino.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_domino.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_domino.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_domino.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_domino.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_domino.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_domino.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_domino.IMP_CONTAINER_HAS_CGAL
IMP_CONTAINER_HAS_HDF5 = _IMP_domino.IMP_CONTAINER_HAS_HDF5
IMPCONTAINER_SHOW_WARNINGS = _IMP_domino.IMPCONTAINER_SHOW_WARNINGS
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_domino.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_domino.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_domino.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_domino.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_domino.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_domino.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_domino.IMP_ATOM_HAS_CGAL
IMP_ATOM_HAS_HDF5 = _IMP_domino.IMP_ATOM_HAS_HDF5
IMPATOM_SHOW_WARNINGS = _IMP_domino.IMPATOM_SHOW_WARNINGS
IMP_ATOM_TYPE_INDEX = _IMP_domino.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_domino.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_domino.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_RMF_HAS_IMP_BASE = _IMP_domino.IMP_RMF_HAS_IMP_BASE
IMP_RMF_HAS_IMP_CGAL = _IMP_domino.IMP_RMF_HAS_IMP_CGAL
IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_RMF_HAS_BOOST_FILESYSTEM
IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
IMP_RMF_HAS_BOOST_RANDOM = _IMP_domino.IMP_RMF_HAS_BOOST_RANDOM
IMP_RMF_HAS_BOOST_REGEX = _IMP_domino.IMP_RMF_HAS_BOOST_REGEX
IMP_RMF_HAS_BOOST_SYSTEM = _IMP_domino.IMP_RMF_HAS_BOOST_SYSTEM
IMP_RMF_HAS_CGAL = _IMP_domino.IMP_RMF_HAS_CGAL
IMP_RMF_HAS_HDF5 = _IMP_domino.IMP_RMF_HAS_HDF5
IMPRMF_SHOW_WARNINGS = _IMP_domino.IMPRMF_SHOW_WARNINGS
import IMP.rmf
import RMF
IMP_DOMINO_HAS_IMP_ATOM = _IMP_domino.IMP_DOMINO_HAS_IMP_ATOM
IMP_DOMINO_HAS_IMP_BASE = _IMP_domino.IMP_DOMINO_HAS_IMP_BASE
IMP_DOMINO_HAS_IMP_CGAL = _IMP_domino.IMP_DOMINO_HAS_IMP_CGAL
IMP_DOMINO_HAS_IMP_KERNEL = _IMP_domino.IMP_DOMINO_HAS_IMP_KERNEL
IMP_DOMINO_HAS_IMP_RMF = _IMP_domino.IMP_DOMINO_HAS_IMP_RMF
IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_DOMINO_HAS_BOOST_FILESYSTEM
IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_domino.IMP_DOMINO_HAS_BOOST_RANDOM
IMP_DOMINO_HAS_BOOST_REGEX = _IMP_domino.IMP_DOMINO_HAS_BOOST_REGEX
IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_domino.IMP_DOMINO_HAS_BOOST_SYSTEM
IMP_DOMINO_HAS_CGAL = _IMP_domino.IMP_DOMINO_HAS_CGAL
IMP_DOMINO_HAS_HDF5 = _IMP_domino.IMP_DOMINO_HAS_HDF5
IMP_DOMINO_HAS_RMF = _IMP_domino.IMP_DOMINO_HAS_RMF
IMPDOMINO_SHOW_WARNINGS = _IMP_domino.IMPDOMINO_SHOW_WARNINGS
import RMF_HDF5
_object_types.append("DiscreteSampler")


def _object_cast_to_DiscreteSampler(*args):
  """_object_cast_to_DiscreteSampler(Object o) -> DiscreteSampler"""
  return _IMP_domino._object_cast_to_DiscreteSampler(*args)
_object_types.append("ParticleStates")


def _object_cast_to_ParticleStates(*args):
  """_object_cast_to_ParticleStates(Object o) -> ParticleStates"""
  return _IMP_domino._object_cast_to_ParticleStates(*args)
_object_types.append("SubsetFilter")


def _object_cast_to_SubsetFilter(*args):
  """_object_cast_to_SubsetFilter(Object o) -> SubsetFilter"""
  return _IMP_domino._object_cast_to_SubsetFilter(*args)
_object_types.append("SubsetFilterTable")


def _object_cast_to_SubsetFilterTable(*args):
  """_object_cast_to_SubsetFilterTable(Object o) -> SubsetFilterTable"""
  return _IMP_domino._object_cast_to_SubsetFilterTable(*args)
_object_types.append("AssignmentsTable")


def _object_cast_to_AssignmentsTable(*args):
  """_object_cast_to_AssignmentsTable(Object o) -> AssignmentsTable"""
  return _IMP_domino._object_cast_to_AssignmentsTable(*args)
_object_types.append("AssignmentContainer")


def _object_cast_to_AssignmentContainer(*args):
  """_object_cast_to_AssignmentContainer(Object o) -> AssignmentContainer"""
  return _IMP_domino._object_cast_to_AssignmentContainer(*args)
class InteractionGraph(IMP.base.Object):
    """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::InteractionGraph,p.IMP::kernel::Particle,IMP::domino::ShowInteractionGraphVertex)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InteractionGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InteractionGraph, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::InteractionGraph,p.IMP::kernel::Particle,IMP::domino::ShowInteractionGraphVertex)> self) -> InteractionGraph"""
        this = _IMP_domino.new_InteractionGraph()
        try: self.this.append(this)
        except: self.this = this
    def get_graph(self):
        """get_graph(InteractionGraph self) -> IMP::domino::InteractionGraph const &"""
        return _IMP_domino.InteractionGraph_get_graph(self)

    def get_vertices(self):
        """get_vertices(InteractionGraph self) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptors"""
        return _IMP_domino.InteractionGraph_get_vertices(self)

    def get_vertex_name(self, *args):
        """get_vertex_name(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor i) -> Particle"""
        return _IMP_domino.InteractionGraph_get_vertex_name(self, *args)

    def get_in_neighbors(self, *args):
        """get_in_neighbors(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptors"""
        return _IMP_domino.InteractionGraph_get_in_neighbors(self, *args)

    def get_out_neighbors(self, *args):
        """get_out_neighbors(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptors"""
        return _IMP_domino.InteractionGraph_get_out_neighbors(self, *args)

    def show_graphviz(self, *args):
        """
        show_graphviz(InteractionGraph self, _ostream out=std::cout)
        show_graphviz(InteractionGraph self)
        """
        return _IMP_domino.InteractionGraph_show_graphviz(self, *args)

    def get_graphviz_string(self):
        """get_graphviz_string(InteractionGraph self) -> std::string"""
        return _IMP_domino.InteractionGraph_get_graphviz_string(self)

    def add_edge(self, *args):
        """
        add_edge(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor v0, 
            IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor v1)
        """
        return _IMP_domino.InteractionGraph_add_edge(self, *args)

    def add_vertex(self, *args):
        """add_vertex(InteractionGraph self, Particle l) -> IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor"""
        return _IMP_domino.InteractionGraph_add_vertex(self, *args)

    def remove_vertex(self, *args):
        """remove_vertex(InteractionGraph self, IMP::base::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::kernel::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor l)"""
        return _IMP_domino.InteractionGraph_remove_vertex(self, *args)

    __swig_destroy__ = _IMP_domino.delete_InteractionGraph
    __del__ = lambda self : None;
InteractionGraph_swigregister = _IMP_domino.InteractionGraph_swigregister
InteractionGraph_swigregister(InteractionGraph)

_value_types.append("InteractionGraph")

class SubsetGraph(IMP.base.Object):
    """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubsetGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SubsetGraph, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex)> self) -> SubsetGraph"""
        this = _IMP_domino.new_SubsetGraph()
        try: self.this.append(this)
        except: self.this = this
    def get_graph(self):
        """get_graph(SubsetGraph self) -> IMP::domino::SubsetGraph const &"""
        return _IMP_domino.SubsetGraph_get_graph(self)

    def get_vertices(self):
        """get_vertices(SubsetGraph self) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptors"""
        return _IMP_domino.SubsetGraph_get_vertices(self)

    def get_vertex_name(self, *args):
        """get_vertex_name(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor i) -> Subset"""
        return _IMP_domino.SubsetGraph_get_vertex_name(self, *args)

    def get_in_neighbors(self, *args):
        """get_in_neighbors(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptors"""
        return _IMP_domino.SubsetGraph_get_in_neighbors(self, *args)

    def get_out_neighbors(self, *args):
        """get_out_neighbors(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptors"""
        return _IMP_domino.SubsetGraph_get_out_neighbors(self, *args)

    def show_graphviz(self, *args):
        """
        show_graphviz(SubsetGraph self, _ostream out=std::cout)
        show_graphviz(SubsetGraph self)
        """
        return _IMP_domino.SubsetGraph_show_graphviz(self, *args)

    def get_graphviz_string(self):
        """get_graphviz_string(SubsetGraph self) -> std::string"""
        return _IMP_domino.SubsetGraph_get_graphviz_string(self)

    def add_edge(self, *args):
        """
        add_edge(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor v0, 
            IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor v1)
        """
        return _IMP_domino.SubsetGraph_add_edge(self, *args)

    def add_vertex(self, *args):
        """add_vertex(SubsetGraph self, Subset l) -> IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor"""
        return _IMP_domino.SubsetGraph_add_vertex(self, *args)

    def remove_vertex(self, *args):
        """remove_vertex(SubsetGraph self, IMP::base::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor l)"""
        return _IMP_domino.SubsetGraph_remove_vertex(self, *args)

    __swig_destroy__ = _IMP_domino.delete_SubsetGraph
    __del__ = lambda self : None;
SubsetGraph_swigregister = _IMP_domino.SubsetGraph_swigregister
SubsetGraph_swigregister(SubsetGraph)

_value_types.append("SubsetGraph")

class CliqueGraph(IMP.base.Object):
    """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CliqueGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CliqueGraph, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex)> self) -> CliqueGraph"""
        this = _IMP_domino.new_CliqueGraph()
        try: self.this.append(this)
        except: self.this = this
    def get_graph(self):
        """get_graph(CliqueGraph self) -> IMP::domino::CliqueGraph const &"""
        return _IMP_domino.CliqueGraph_get_graph(self)

    def get_vertices(self):
        """get_vertices(CliqueGraph self) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptors"""
        return _IMP_domino.CliqueGraph_get_vertices(self)

    def get_vertex_name(self, *args):
        """get_vertex_name(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor i) -> Subset"""
        return _IMP_domino.CliqueGraph_get_vertex_name(self, *args)

    def get_in_neighbors(self, *args):
        """get_in_neighbors(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptors"""
        return _IMP_domino.CliqueGraph_get_in_neighbors(self, *args)

    def get_out_neighbors(self, *args):
        """get_out_neighbors(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptors"""
        return _IMP_domino.CliqueGraph_get_out_neighbors(self, *args)

    def show_graphviz(self, *args):
        """
        show_graphviz(CliqueGraph self, _ostream out=std::cout)
        show_graphviz(CliqueGraph self)
        """
        return _IMP_domino.CliqueGraph_show_graphviz(self, *args)

    def get_graphviz_string(self):
        """get_graphviz_string(CliqueGraph self) -> std::string"""
        return _IMP_domino.CliqueGraph_get_graphviz_string(self)

    def add_edge(self, *args):
        """
        add_edge(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor v0, 
            IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor v1)
        """
        return _IMP_domino.CliqueGraph_add_edge(self, *args)

    def add_vertex(self, *args):
        """add_vertex(CliqueGraph self, Subset l) -> IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor"""
        return _IMP_domino.CliqueGraph_add_vertex(self, *args)

    def remove_vertex(self, *args):
        """remove_vertex(CliqueGraph self, IMP::base::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor l)"""
        return _IMP_domino.CliqueGraph_remove_vertex(self, *args)

    __swig_destroy__ = _IMP_domino.delete_CliqueGraph
    __del__ = lambda self : None;
CliqueGraph_swigregister = _IMP_domino.CliqueGraph_swigregister
CliqueGraph_swigregister(CliqueGraph)

_value_types.append("CliqueGraph")

class MergeTree(IMP.base.Object):
    """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MergeTree, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MergeTree, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::base::internal::BoostDigraph<(IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex)> self) -> MergeTree"""
        this = _IMP_domino.new_MergeTree()
        try: self.this.append(this)
        except: self.this = this
    def get_graph(self):
        """get_graph(MergeTree self) -> IMP::domino::MergeTree const &"""
        return _IMP_domino.MergeTree_get_graph(self)

    def get_vertices(self):
        """get_vertices(MergeTree self) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptors"""
        return _IMP_domino.MergeTree_get_vertices(self)

    def get_vertex_name(self, *args):
        """get_vertex_name(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor i) -> Subset"""
        return _IMP_domino.MergeTree_get_vertex_name(self, *args)

    def get_in_neighbors(self, *args):
        """get_in_neighbors(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptors"""
        return _IMP_domino.MergeTree_get_in_neighbors(self, *args)

    def get_out_neighbors(self, *args):
        """get_out_neighbors(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor v) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptors"""
        return _IMP_domino.MergeTree_get_out_neighbors(self, *args)

    def show_graphviz(self, *args):
        """
        show_graphviz(MergeTree self, _ostream out=std::cout)
        show_graphviz(MergeTree self)
        """
        return _IMP_domino.MergeTree_show_graphviz(self, *args)

    def get_graphviz_string(self):
        """get_graphviz_string(MergeTree self) -> std::string"""
        return _IMP_domino.MergeTree_get_graphviz_string(self)

    def add_edge(self, *args):
        """
        add_edge(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor v0, 
            IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor v1)
        """
        return _IMP_domino.MergeTree_add_edge(self, *args)

    def add_vertex(self, *args):
        """add_vertex(MergeTree self, Subset l) -> IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor"""
        return _IMP_domino.MergeTree_add_vertex(self, *args)

    def remove_vertex(self, *args):
        """remove_vertex(MergeTree self, IMP::base::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor l)"""
        return _IMP_domino.MergeTree_remove_vertex(self, *args)

    __swig_destroy__ = _IMP_domino.delete_MergeTree
    __del__ = lambda self : None;
MergeTree_swigregister = _IMP_domino.MergeTree_swigregister
MergeTree_swigregister(MergeTree)

_value_types.append("MergeTree")

_object_types.append("BranchAndBoundSampler")


def _object_cast_to_BranchAndBoundSampler(*args):
  """_object_cast_to_BranchAndBoundSampler(Object o) -> BranchAndBoundSampler"""
  return _IMP_domino._object_cast_to_BranchAndBoundSampler(*args)
_object_types.append("BranchAndBoundAssignmentsTable")


def _object_cast_to_BranchAndBoundAssignmentsTable(*args):
  """_object_cast_to_BranchAndBoundAssignmentsTable(Object o) -> BranchAndBoundAssignmentsTable"""
  return _IMP_domino._object_cast_to_BranchAndBoundAssignmentsTable(*args)
_object_types.append("RecursiveAssignmentsTable")


def _object_cast_to_RecursiveAssignmentsTable(*args):
  """_object_cast_to_RecursiveAssignmentsTable(Object o) -> RecursiveAssignmentsTable"""
  return _IMP_domino._object_cast_to_RecursiveAssignmentsTable(*args)
_object_types.append("SimpleAssignmentsTable")


def _object_cast_to_SimpleAssignmentsTable(*args):
  """_object_cast_to_SimpleAssignmentsTable(Object o) -> SimpleAssignmentsTable"""
  return _IMP_domino._object_cast_to_SimpleAssignmentsTable(*args)
_object_types.append("CompoundStates")


def _object_cast_to_CompoundStates(*args):
  """_object_cast_to_CompoundStates(Object o) -> CompoundStates"""
  return _IMP_domino._object_cast_to_CompoundStates(*args)
_object_types.append("DisjointSetsSubsetFilterTable")


def _object_cast_to_DisjointSetsSubsetFilterTable(*args):
  """_object_cast_to_DisjointSetsSubsetFilterTable(Object o) -> DisjointSetsSubsetFilterTable"""
  return _IMP_domino._object_cast_to_DisjointSetsSubsetFilterTable(*args)
_object_types.append("MinimumRestraintScoreSubsetFilterTable")


def _object_cast_to_MinimumRestraintScoreSubsetFilterTable(*args):
  """_object_cast_to_MinimumRestraintScoreSubsetFilterTable(Object o) -> MinimumRestraintScoreSubsetFilterTable"""
  return _IMP_domino._object_cast_to_MinimumRestraintScoreSubsetFilterTable(*args)
_object_types.append("DominoSampler")


def _object_cast_to_DominoSampler(*args):
  """_object_cast_to_DominoSampler(Object o) -> DominoSampler"""
  return _IMP_domino._object_cast_to_DominoSampler(*args)
_object_types.append("EqualitySubsetFilterTable")


def _object_cast_to_EqualitySubsetFilterTable(*args):
  """_object_cast_to_EqualitySubsetFilterTable(Object o) -> EqualitySubsetFilterTable"""
  return _IMP_domino._object_cast_to_EqualitySubsetFilterTable(*args)
_object_types.append("EquivalenceSubsetFilterTable")


def _object_cast_to_EquivalenceSubsetFilterTable(*args):
  """_object_cast_to_EquivalenceSubsetFilterTable(Object o) -> EquivalenceSubsetFilterTable"""
  return _IMP_domino._object_cast_to_EquivalenceSubsetFilterTable(*args)
_object_types.append("EquivalenceAndExclusionSubsetFilterTable")


def _object_cast_to_EquivalenceAndExclusionSubsetFilterTable(*args):
  """_object_cast_to_EquivalenceAndExclusionSubsetFilterTable(Object o) -> EquivalenceAndExclusionSubsetFilterTable"""
  return _IMP_domino._object_cast_to_EquivalenceAndExclusionSubsetFilterTable(*args)
_object_types.append("ExclusionSubsetFilterTable")


def _object_cast_to_ExclusionSubsetFilterTable(*args):
  """_object_cast_to_ExclusionSubsetFilterTable(Object o) -> ExclusionSubsetFilterTable"""
  return _IMP_domino._object_cast_to_ExclusionSubsetFilterTable(*args)
_object_types.append("IndexStates")


def _object_cast_to_IndexStates(*args):
  """_object_cast_to_IndexStates(Object o) -> IndexStates"""
  return _IMP_domino._object_cast_to_IndexStates(*args)
_object_types.append("ListSubsetFilterTable")


def _object_cast_to_ListSubsetFilterTable(*args):
  """_object_cast_to_ListSubsetFilterTable(Object o) -> ListSubsetFilterTable"""
  return _IMP_domino._object_cast_to_ListSubsetFilterTable(*args)
_object_types.append("ListAssignmentsTable")


def _object_cast_to_ListAssignmentsTable(*args):
  """_object_cast_to_ListAssignmentsTable(Object o) -> ListAssignmentsTable"""
  return _IMP_domino._object_cast_to_ListAssignmentsTable(*args)
_object_types.append("ParticleStatesTable")


def _object_cast_to_ParticleStatesTable(*args):
  """_object_cast_to_ParticleStatesTable(Object o) -> ParticleStatesTable"""
  return _IMP_domino._object_cast_to_ParticleStatesTable(*args)
_object_types.append("RecursiveStates")


def _object_cast_to_RecursiveStates(*args):
  """_object_cast_to_RecursiveStates(Object o) -> RecursiveStates"""
  return _IMP_domino._object_cast_to_RecursiveStates(*args)
_object_types.append("ProbabilisticSubsetFilterTable")


def _object_cast_to_ProbabilisticSubsetFilterTable(*args):
  """_object_cast_to_ProbabilisticSubsetFilterTable(Object o) -> ProbabilisticSubsetFilterTable"""
  return _IMP_domino._object_cast_to_ProbabilisticSubsetFilterTable(*args)
_object_types.append("RestraintScoreSubsetFilterTable")


def _object_cast_to_RestraintScoreSubsetFilterTable(*args):
  """_object_cast_to_RestraintScoreSubsetFilterTable(Object o) -> RestraintScoreSubsetFilterTable"""
  return _IMP_domino._object_cast_to_RestraintScoreSubsetFilterTable(*args)
_object_types.append("RigidBodyStates")


def _object_cast_to_RigidBodyStates(*args):
  """_object_cast_to_RigidBodyStates(Object o) -> RigidBodyStates"""
  return _IMP_domino._object_cast_to_RigidBodyStates(*args)
_object_types.append("XYZStates")


def _object_cast_to_XYZStates(*args):
  """_object_cast_to_XYZStates(Object o) -> XYZStates"""
  return _IMP_domino._object_cast_to_XYZStates(*args)
_object_types.append("NestedRigidBodyStates")


def _object_cast_to_NestedRigidBodyStates(*args):
  """_object_cast_to_NestedRigidBodyStates(Object o) -> NestedRigidBodyStates"""
  return _IMP_domino._object_cast_to_NestedRigidBodyStates(*args)
_object_types.append("DependencyScoreState")


def _object_cast_to_DependencyScoreState(*args):
  """_object_cast_to_DependencyScoreState(Object o) -> DependencyScoreState"""
  return _IMP_domino._object_cast_to_DependencyScoreState(*args)
_object_types.append("PairListSubsetFilterTable")


def _object_cast_to_PairListSubsetFilterTable(*args):
  """_object_cast_to_PairListSubsetFilterTable(Object o) -> PairListSubsetFilterTable"""
  return _IMP_domino._object_cast_to_PairListSubsetFilterTable(*args)
_object_types.append("ListAssignmentContainer")


def _object_cast_to_ListAssignmentContainer(*args):
  """_object_cast_to_ListAssignmentContainer(Object o) -> ListAssignmentContainer"""
  return _IMP_domino._object_cast_to_ListAssignmentContainer(*args)
_object_types.append("PackedAssignmentContainer")


def _object_cast_to_PackedAssignmentContainer(*args):
  """_object_cast_to_PackedAssignmentContainer(Object o) -> PackedAssignmentContainer"""
  return _IMP_domino._object_cast_to_PackedAssignmentContainer(*args)
_object_types.append("HeapAssignmentContainer")


def _object_cast_to_HeapAssignmentContainer(*args):
  """_object_cast_to_HeapAssignmentContainer(Object o) -> HeapAssignmentContainer"""
  return _IMP_domino._object_cast_to_HeapAssignmentContainer(*args)
_object_types.append("RangeViewAssignmentContainer")


def _object_cast_to_RangeViewAssignmentContainer(*args):
  """_object_cast_to_RangeViewAssignmentContainer(Object o) -> RangeViewAssignmentContainer"""
  return _IMP_domino._object_cast_to_RangeViewAssignmentContainer(*args)
_object_types.append("SampleAssignmentContainer")


def _object_cast_to_SampleAssignmentContainer(*args):
  """_object_cast_to_SampleAssignmentContainer(Object o) -> SampleAssignmentContainer"""
  return _IMP_domino._object_cast_to_SampleAssignmentContainer(*args)
_object_types.append("PermutationStates")


def _object_cast_to_PermutationStates(*args):
  """_object_cast_to_PermutationStates(Object o) -> PermutationStates"""
  return _IMP_domino._object_cast_to_PermutationStates(*args)
_object_types.append("WriteHDF5AssignmentContainer")


def _object_cast_to_WriteHDF5AssignmentContainer(*args):
  """_object_cast_to_WriteHDF5AssignmentContainer(Object o) -> WriteHDF5AssignmentContainer"""
  return _IMP_domino._object_cast_to_WriteHDF5AssignmentContainer(*args)
_object_types.append("ReadHDF5AssignmentContainer")


def _object_cast_to_ReadHDF5AssignmentContainer(*args):
  """_object_cast_to_ReadHDF5AssignmentContainer(Object o) -> ReadHDF5AssignmentContainer"""
  return _IMP_domino._object_cast_to_ReadHDF5AssignmentContainer(*args)
_object_types.append("ReadAssignmentContainer")


def _object_cast_to_ReadAssignmentContainer(*args):
  """_object_cast_to_ReadAssignmentContainer(Object o) -> ReadAssignmentContainer"""
  return _IMP_domino._object_cast_to_ReadAssignmentContainer(*args)
_object_types.append("WriteAssignmentContainer")


def _object_cast_to_WriteAssignmentContainer(*args):
  """_object_cast_to_WriteAssignmentContainer(Object o) -> WriteAssignmentContainer"""
  return _IMP_domino._object_cast_to_WriteAssignmentContainer(*args)
_object_types.append("CappedAssignmentContainer")


def _object_cast_to_CappedAssignmentContainer(*args):
  """_object_cast_to_CappedAssignmentContainer(Object o) -> CappedAssignmentContainer"""
  return _IMP_domino._object_cast_to_CappedAssignmentContainer(*args)
_object_types.append("RestraintCache")


def _object_cast_to_RestraintCache(*args):
  """_object_cast_to_RestraintCache(Object o) -> RestraintCache"""
  return _IMP_domino._object_cast_to_RestraintCache(*args)
Subsets=list
_plural_types.append("Subsets")
_value_types.append("Subset")

Assignments=list
_plural_types.append("Assignments")
_value_types.append("Assignment")

Slices=list
_plural_types.append("Slices")
_value_types.append("Slice")

Orders=list
_plural_types.append("Orders")
_value_types.append("Order")

class _IntArray(IMP.base._Value):
    """Proxy of C++ IMP::base::ConstVector<(int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntArray, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntArray, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete__IntArray
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::base::ConstVector<(int)> self, unsigned int sz, int fill) -> _IntArray
        __init__(IMP::base::ConstVector<(int)> self) -> _IntArray
        """
        this = _IMP_domino.new__IntArray(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """__eq__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___ge__(self, *args)

    def __le__(self, *args):
        """__le__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___le__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(_IntArray self, unsigned int i) -> int"""
        return _IMP_domino._IntArray___getitem__(self, *args)

    def __len__(self):
        """__len__(_IntArray self) -> unsigned int"""
        return _IMP_domino._IntArray___len__(self)

    def show(self, *args):
        """
        show(_IntArray self, _ostream out=std::cout)
        show(_IntArray self)
        """
        return _IMP_domino._IntArray_show(self, *args)

    def __hash__(self):
        """__hash__(_IntArray self) -> std::size_t"""
        return _IMP_domino._IntArray___hash__(self)

_IntArray_swigregister = _IMP_domino._IntArray_swigregister
_IntArray_swigregister(_IntArray)

class _UIntArray(IMP.base._Value):
    """Proxy of C++ IMP::base::ConstVector<(unsigned int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _UIntArray, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _UIntArray, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete__UIntArray
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::base::ConstVector<(unsigned int)> self, unsigned int sz, unsigned int fill) -> _UIntArray
        __init__(IMP::base::ConstVector<(unsigned int)> self) -> _UIntArray
        """
        this = _IMP_domino.new__UIntArray(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """__eq__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___ge__(self, *args)

    def __le__(self, *args):
        """__le__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___le__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(_UIntArray self, unsigned int i) -> unsigned int"""
        return _IMP_domino._UIntArray___getitem__(self, *args)

    def __len__(self):
        """__len__(_UIntArray self) -> unsigned int"""
        return _IMP_domino._UIntArray___len__(self)

    def show(self, *args):
        """
        show(_UIntArray self, _ostream out=std::cout)
        show(_UIntArray self)
        """
        return _IMP_domino._UIntArray_show(self, *args)

    def __hash__(self):
        """__hash__(_UIntArray self) -> std::size_t"""
        return _IMP_domino._UIntArray___hash__(self)

_UIntArray_swigregister = _IMP_domino._UIntArray_swigregister
_UIntArray_swigregister(_UIntArray)

class _ParticleArray(IMP.base._Value):
    """Proxy of C++ IMP::base::ConstVector<(IMP::base::WeakPointer<(Particle)>,p.Particle)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleArray, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleArray, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete__ParticleArray
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::base::ConstVector<(IMP::base::WeakPointer<(Particle)>,p.Particle)> self, unsigned int sz, IMP::base::WeakPointer< IMP::kernel::Particle > fill) -> _ParticleArray
        __init__(IMP::base::ConstVector<(IMP::base::WeakPointer<(Particle)>,p.Particle)> self) -> _ParticleArray
        """
        this = _IMP_domino.new__ParticleArray(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """__eq__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___ge__(self, *args)

    def __le__(self, *args):
        """__le__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___le__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(_ParticleArray self, unsigned int i) -> Particle"""
        return _IMP_domino._ParticleArray___getitem__(self, *args)

    def __len__(self):
        """__len__(_ParticleArray self) -> unsigned int"""
        return _IMP_domino._ParticleArray___len__(self)

    def show(self, *args):
        """
        show(_ParticleArray self, _ostream out=std::cout)
        show(_ParticleArray self)
        """
        return _IMP_domino._ParticleArray_show(self, *args)

    def __hash__(self):
        """__hash__(_ParticleArray self) -> std::size_t"""
        return _IMP_domino._ParticleArray___hash__(self)

_ParticleArray_swigregister = _IMP_domino._ParticleArray_swigregister
_ParticleArray_swigregister(_ParticleArray)

class Subset(_ParticleArray):
    """Proxy of C++ IMP::domino::Subset class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleArray]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Subset, name, value)
    __swig_getmethods__ = {}
    for _s in [_ParticleArray]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Subset, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::Subset self, IMP::kernel::ParticlesTemp const & ps, bool arg3) -> Subset
        __init__(IMP::domino::Subset self) -> Subset
        __init__(IMP::domino::Subset self, IMP::kernel::ParticlesTemp ps) -> Subset
        """
        this = _IMP_domino.new_Subset(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_model(self):
        """get_model(Subset self) -> Model"""
        return _IMP_domino.Subset_get_model(self)

    def get_name(self):
        """get_name(Subset self) -> std::string"""
        return _IMP_domino.Subset_get_name(self)

    def get_contains(self, *args):
        """get_contains(Subset self, Subset o) -> bool"""
        return _IMP_domino.Subset_get_contains(self, *args)

    def __str__(self):
        """__str__(Subset self) -> std::string"""
        return _IMP_domino.Subset___str__(self)

    def __repr__(self):
        """__repr__(Subset self) -> std::string"""
        return _IMP_domino.Subset___repr__(self)

    __swig_destroy__ = _IMP_domino.delete_Subset
    __del__ = lambda self : None;
Subset_swigregister = _IMP_domino.Subset_swigregister
Subset_swigregister(Subset)


def get_union(*args):
  """get_union(Subset a, Subset b) -> Subset"""
  return _IMP_domino.get_union(*args)

def get_intersection(*args):
  """get_intersection(Subset a, Subset b) -> Subset"""
  return _IMP_domino.get_intersection(*args)

def get_difference(*args):
  """get_difference(Subset a, Subset b) -> Subset"""
  return _IMP_domino.get_difference(*args)
class Assignment(_IntArray):
    """Proxy of C++ IMP::domino::Assignment class"""
    __swig_setmethods__ = {}
    for _s in [_IntArray]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Assignment, name, value)
    __swig_getmethods__ = {}
    for _s in [_IntArray]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Assignment, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::Assignment self) -> Assignment
        __init__(IMP::domino::Assignment self, unsigned int sz) -> Assignment
        __init__(IMP::domino::Assignment self, IMP::Ints const & i) -> Assignment
        """
        this = _IMP_domino.new_Assignment(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(Assignment self) -> std::string"""
        return _IMP_domino.Assignment___str__(self)

    def __repr__(self):
        """__repr__(Assignment self) -> std::string"""
        return _IMP_domino.Assignment___repr__(self)

    __swig_destroy__ = _IMP_domino.delete_Assignment
    __del__ = lambda self : None;
Assignment_swigregister = _IMP_domino.Assignment_swigregister
Assignment_swigregister(Assignment)

class Slice(_UIntArray):
    """Proxy of C++ IMP::domino::Slice class"""
    __swig_setmethods__ = {}
    for _s in [_UIntArray]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Slice, name, value)
    __swig_getmethods__ = {}
    for _s in [_UIntArray]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Slice, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::Slice self) -> Slice
        __init__(IMP::domino::Slice self, Subset outer, Subset inner) -> Slice
        """
        this = _IMP_domino.new_Slice(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_sliced(self, *args):
        """
        get_sliced(Slice self, Assignment a) -> Assignment
        get_sliced(Slice self, Subset a) -> Subset
        """
        return _IMP_domino.Slice_get_sliced(self, *args)

    def __str__(self):
        """__str__(Slice self) -> std::string"""
        return _IMP_domino.Slice___str__(self)

    def __repr__(self):
        """__repr__(Slice self) -> std::string"""
        return _IMP_domino.Slice___repr__(self)

    __swig_destroy__ = _IMP_domino.delete_Slice
    __del__ = lambda self : None;
Slice_swigregister = _IMP_domino.Slice_swigregister
Slice_swigregister(Slice)


def get_slice(*args):
  """get_slice(Subset outer, Subset inner, IMP::domino::Subsets const & excluded) -> Slice"""
  return _IMP_domino.get_slice(*args)
class Order(_UIntArray):
    """Proxy of C++ IMP::domino::Order class"""
    __swig_setmethods__ = {}
    for _s in [_UIntArray]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Order, name, value)
    __swig_getmethods__ = {}
    for _s in [_UIntArray]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Order, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::Order self) -> Order
        __init__(IMP::domino::Order self, Subset outer, IMP::kernel::ParticlesTemp const & order) -> Order
        """
        this = _IMP_domino.new_Order(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_list_ordered(self, *args):
        """get_list_ordered(Order self, Assignment a) -> IMP::Ints"""
        return _IMP_domino.Order_get_list_ordered(self, *args)

    def get_subset_ordered(self, *args):
        """get_subset_ordered(Order self, IMP::Ints const & a) -> Assignment"""
        return _IMP_domino.Order_get_subset_ordered(self, *args)

    def __str__(self):
        """__str__(Order self) -> std::string"""
        return _IMP_domino.Order___str__(self)

    def __repr__(self):
        """__repr__(Order self) -> std::string"""
        return _IMP_domino.Order___repr__(self)

    __swig_destroy__ = _IMP_domino.delete_Order
    __del__ = lambda self : None;
Order_swigregister = _IMP_domino.Order_swigregister
Order_swigregister(Order)

class ParticleStates(IMP.base.Object):
    """Proxy of C++ IMP::domino::ParticleStates class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleStates, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleStates, name)
    def __init__(self, name="ParticleStates %1%"): 
        """
        __init__(IMP::domino::ParticleStates self, std::string name="ParticleStates %1%") -> ParticleStates
        __init__(IMP::domino::ParticleStates self) -> ParticleStates
        """
        if self.__class__ == ParticleStates:
            _self = None
        else:
            _self = self
        this = _IMP_domino.new_ParticleStates(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != ParticleStates:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_number_of_particle_states(self):
        """get_number_of_particle_states(ParticleStates self) -> unsigned int"""
        return _IMP_domino.ParticleStates_get_number_of_particle_states(self)

    def load_particle_state(self, *args):
        """load_particle_state(ParticleStates self, unsigned int arg0, Particle arg1)"""
        return _IMP_domino.ParticleStates_load_particle_state(self, *args)

    def get_embedding(self, *args):
        """get_embedding(ParticleStates self, unsigned int i) -> VectorKD"""
        return _IMP_domino.ParticleStates_get_embedding(self, *args)

    def get_nearest_state(self, *args):
        """get_nearest_state(ParticleStates self, VectorKD v) -> unsigned int"""
        return _IMP_domino.ParticleStates_get_nearest_state(self, *args)

    __swig_destroy__ = _IMP_domino.delete_ParticleStates
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ParticleStates self) -> std::string"""
        return _IMP_domino.ParticleStates___str__(self)

    def __repr__(self):
        """__repr__(ParticleStates self) -> std::string"""
        return _IMP_domino.ParticleStates___repr__(self)

    def get_from(o):
       return _object_cast_to_ParticleStates(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::domino" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_ParticleStates(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_ParticleStates(self)
        return weakref_proxy(self)
ParticleStates_swigregister = _IMP_domino.ParticleStates_swigregister
ParticleStates_swigregister(ParticleStates)

class ParticleStatesTable(IMP.base.Object):
    """Proxy of C++ IMP::domino::ParticleStatesTable class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleStatesTable, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleStatesTable, name)
    def __init__(self): 
        """__init__(IMP::domino::ParticleStatesTable self) -> ParticleStatesTable"""
        this = _IMP_domino.new_ParticleStatesTable()
        try: self.this.append(this)
        except: self.this = this
    def get_particle_states(self, *args):
        """get_particle_states(ParticleStatesTable self, Particle p) -> ParticleStates"""
        return _IMP_domino.ParticleStatesTable_get_particle_states(self, *args)

    def get_has_particle(self, *args):
        """get_has_particle(ParticleStatesTable self, Particle p) -> bool"""
        return _IMP_domino.ParticleStatesTable_get_has_particle(self, *args)

    def get_particles(self):
        """get_particles(ParticleStatesTable self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_domino.ParticleStatesTable_get_particles(self)

    def get_subset(self):
        """get_subset(ParticleStatesTable self) -> Subset"""
        return _IMP_domino.ParticleStatesTable_get_subset(self)

    def set_particle_states(self, *args):
        """set_particle_states(ParticleStatesTable self, Particle p, ParticleStates e)"""
        return _IMP_domino.ParticleStatesTable_set_particle_states(self, *args)

    def get_version_info(self):
        """get_version_info(ParticleStatesTable self) -> VersionInfo"""
        return _IMP_domino.ParticleStatesTable_get_version_info(self)

    def __str__(self):
        """__str__(ParticleStatesTable self) -> std::string"""
        return _IMP_domino.ParticleStatesTable___str__(self)

    def __repr__(self):
        """__repr__(ParticleStatesTable self) -> std::string"""
        return _IMP_domino.ParticleStatesTable___repr__(self)

    def get_from(o):
       return _object_cast_to_ParticleStatesTable(o)
    get_from = staticmethod(get_from)

ParticleStatesTable_swigregister = _IMP_domino.ParticleStatesTable_swigregister
ParticleStatesTable_swigregister(ParticleStatesTable)

class IndexStates(ParticleStates):
    """Proxy of C++ IMP::domino::IndexStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexStates, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::IndexStates self, unsigned int n, IntKey k=IntKey("state")) -> IndexStates
        __init__(IMP::domino::IndexStates self, unsigned int n) -> IndexStates
        """
        this = _IMP_domino.new_IndexStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(IndexStates self) -> VersionInfo"""
        return _IMP_domino.IndexStates_get_version_info(self)

    def __str__(self):
        """__str__(IndexStates self) -> std::string"""
        return _IMP_domino.IndexStates___str__(self)

    def __repr__(self):
        """__repr__(IndexStates self) -> std::string"""
        return _IMP_domino.IndexStates___repr__(self)

    def get_from(o):
       return _object_cast_to_IndexStates(o)
    get_from = staticmethod(get_from)

IndexStates_swigregister = _IMP_domino.IndexStates_swigregister
IndexStates_swigregister(IndexStates)

class XYZStates(ParticleStates):
    """Proxy of C++ IMP::domino::XYZStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XYZStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XYZStates, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::XYZStates self, IMP::algebra::Vector3Ds const & states) -> XYZStates"""
        this = _IMP_domino.new_XYZStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_vector(self, *args):
        """get_vector(XYZStates self, unsigned int i) -> Vector3D"""
        return _IMP_domino.XYZStates_get_vector(self, *args)

    def get_version_info(self):
        """get_version_info(XYZStates self) -> VersionInfo"""
        return _IMP_domino.XYZStates_get_version_info(self)

    def __str__(self):
        """__str__(XYZStates self) -> std::string"""
        return _IMP_domino.XYZStates___str__(self)

    def __repr__(self):
        """__repr__(XYZStates self) -> std::string"""
        return _IMP_domino.XYZStates___repr__(self)

    def get_from(o):
       return _object_cast_to_XYZStates(o)
    get_from = staticmethod(get_from)

XYZStates_swigregister = _IMP_domino.XYZStates_swigregister
XYZStates_swigregister(XYZStates)

class RigidBodyStates(ParticleStates):
    """Proxy of C++ IMP::domino::RigidBodyStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyStates, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::RigidBodyStates self, IMP::algebra::ReferenceFrame3Ds const & states, double scale=1) -> RigidBodyStates
        __init__(IMP::domino::RigidBodyStates self, IMP::algebra::ReferenceFrame3Ds const & states) -> RigidBodyStates
        """
        this = _IMP_domino.new_RigidBodyStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_reference_frame(self, *args):
        """get_reference_frame(RigidBodyStates self, unsigned int i) -> ReferenceFrame3D"""
        return _IMP_domino.RigidBodyStates_get_reference_frame(self, *args)

    def get_version_info(self):
        """get_version_info(RigidBodyStates self) -> VersionInfo"""
        return _IMP_domino.RigidBodyStates_get_version_info(self)

    def __str__(self):
        """__str__(RigidBodyStates self) -> std::string"""
        return _IMP_domino.RigidBodyStates___str__(self)

    def __repr__(self):
        """__repr__(RigidBodyStates self) -> std::string"""
        return _IMP_domino.RigidBodyStates___repr__(self)

    def get_from(o):
       return _object_cast_to_RigidBodyStates(o)
    get_from = staticmethod(get_from)

RigidBodyStates_swigregister = _IMP_domino.RigidBodyStates_swigregister
RigidBodyStates_swigregister(RigidBodyStates)

class NestedRigidBodyStates(ParticleStates):
    """Proxy of C++ IMP::domino::NestedRigidBodyStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NestedRigidBodyStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NestedRigidBodyStates, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::NestedRigidBodyStates self, IMP::algebra::Transformation3Ds const & states, double scale=100) -> NestedRigidBodyStates
        __init__(IMP::domino::NestedRigidBodyStates self, IMP::algebra::Transformation3Ds const & states) -> NestedRigidBodyStates
        """
        this = _IMP_domino.new_NestedRigidBodyStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_transformation(self, *args):
        """get_transformation(NestedRigidBodyStates self, unsigned int i) -> Transformation3D"""
        return _IMP_domino.NestedRigidBodyStates_get_transformation(self, *args)

    def get_version_info(self):
        """get_version_info(NestedRigidBodyStates self) -> VersionInfo"""
        return _IMP_domino.NestedRigidBodyStates_get_version_info(self)

    def __str__(self):
        """__str__(NestedRigidBodyStates self) -> std::string"""
        return _IMP_domino.NestedRigidBodyStates___str__(self)

    def __repr__(self):
        """__repr__(NestedRigidBodyStates self) -> std::string"""
        return _IMP_domino.NestedRigidBodyStates___repr__(self)

    def get_from(o):
       return _object_cast_to_NestedRigidBodyStates(o)
    get_from = staticmethod(get_from)

NestedRigidBodyStates_swigregister = _IMP_domino.NestedRigidBodyStates_swigregister
NestedRigidBodyStates_swigregister(NestedRigidBodyStates)

class CompoundStates(ParticleStates):
    """Proxy of C++ IMP::domino::CompoundStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompoundStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompoundStates, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::CompoundStates self, ParticleStates a, ParticleStates b) -> CompoundStates"""
        this = _IMP_domino.new_CompoundStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(CompoundStates self) -> VersionInfo"""
        return _IMP_domino.CompoundStates_get_version_info(self)

    def __str__(self):
        """__str__(CompoundStates self) -> std::string"""
        return _IMP_domino.CompoundStates___str__(self)

    def __repr__(self):
        """__repr__(CompoundStates self) -> std::string"""
        return _IMP_domino.CompoundStates___repr__(self)

    def get_from(o):
       return _object_cast_to_CompoundStates(o)
    get_from = staticmethod(get_from)

CompoundStates_swigregister = _IMP_domino.CompoundStates_swigregister
CompoundStates_swigregister(CompoundStates)

class RecursiveStates(ParticleStates):
    """Proxy of C++ IMP::domino::RecursiveStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RecursiveStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RecursiveStates, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::RecursiveStates self, Particle p, Subset s, IMP::domino::Assignments const & ss, ParticleStatesTable pst) -> RecursiveStates"""
        this = _IMP_domino.new_RecursiveStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RecursiveStates self) -> VersionInfo"""
        return _IMP_domino.RecursiveStates_get_version_info(self)

    def __str__(self):
        """__str__(RecursiveStates self) -> std::string"""
        return _IMP_domino.RecursiveStates___str__(self)

    def __repr__(self):
        """__repr__(RecursiveStates self) -> std::string"""
        return _IMP_domino.RecursiveStates___repr__(self)

    def get_from(o):
       return _object_cast_to_RecursiveStates(o)
    get_from = staticmethod(get_from)

RecursiveStates_swigregister = _IMP_domino.RecursiveStates_swigregister
RecursiveStates_swigregister(RecursiveStates)

class PermutationStates(ParticleStates):
    """Proxy of C++ IMP::domino::PermutationStates class"""
    __swig_setmethods__ = {}
    for _s in [ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PermutationStates, name, value)
    __swig_getmethods__ = {}
    for _s in [ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PermutationStates, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::PermutationStates self, ParticleStates inner) -> PermutationStates"""
        this = _IMP_domino.new_PermutationStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_inner_state(self, *args):
        """get_inner_state(PermutationStates self, unsigned int i) -> unsigned int"""
        return _IMP_domino.PermutationStates_get_inner_state(self, *args)

    def get_version_info(self):
        """get_version_info(PermutationStates self) -> VersionInfo"""
        return _IMP_domino.PermutationStates_get_version_info(self)

    def __str__(self):
        """__str__(PermutationStates self) -> std::string"""
        return _IMP_domino.PermutationStates___str__(self)

    def __repr__(self):
        """__repr__(PermutationStates self) -> std::string"""
        return _IMP_domino.PermutationStates___repr__(self)

    def get_from(o):
       return _object_cast_to_PermutationStates(o)
    get_from = staticmethod(get_from)

PermutationStates_swigregister = _IMP_domino.PermutationStates_swigregister
PermutationStates_swigregister(PermutationStates)

class _ParticlesAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::domino::ParticlesAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticlesAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticlesAdaptor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        ParticlesAdaptor(ParticleStatesTable pst) -> _ParticlesAdaptor
        __init__(IMP::domino::ParticlesAdaptor self, IMP::kernel::ParticlesTemp const & ps) -> _ParticlesAdaptor
        """
        this = _IMP_domino.new__ParticlesAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_domino.delete__ParticlesAdaptor
    __del__ = lambda self : None;
_ParticlesAdaptor_swigregister = _IMP_domino._ParticlesAdaptor_swigregister
_ParticlesAdaptor_swigregister(_ParticlesAdaptor)

class RestraintCache(IMP.base.Object):
    """Proxy of C++ IMP::domino::RestraintCache class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintCache, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintCache, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::RestraintCache self, ParticleStatesTable pst, unsigned int size=std::numeric_limits< unsigned int >::max()) -> RestraintCache
        __init__(IMP::domino::RestraintCache self, ParticleStatesTable pst) -> RestraintCache
        """
        this = _IMP_domino.new_RestraintCache(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_restraints(self, *args):
        """add_restraints(RestraintCache self, _RestraintsAdaptor rs)"""
        return _IMP_domino.RestraintCache_add_restraints(self, *args)

    def get_score(self, *args):
        """
        get_score(RestraintCache self, Restraint r, Assignment a) -> double
        get_score(RestraintCache self, Restraint r, Subset s, Assignment a) -> double
        """
        return _IMP_domino.RestraintCache_get_score(self, *args)

    def load_last_score(self, *args):
        """load_last_score(RestraintCache self, Restraint r, Subset s, Assignment a)"""
        return _IMP_domino.RestraintCache_load_last_score(self, *args)

    def get_restraints(self, *args):
        """
        get_restraints(RestraintCache self, Subset s, IMP::domino::Subsets const & exclusions) -> IMP::kernel::RestraintsTemp
        get_restraints(RestraintCache self) -> IMP::kernel::RestraintsTemp
        """
        return _IMP_domino.RestraintCache_get_restraints(self, *args)

    def save_cache(self, *args):
        """
        save_cache(RestraintCache self, IMP::kernel::ParticlesTemp const & particle_ordering, IMP::kernel::RestraintsTemp const & restraints, 
            Group group, unsigned int max_entries)
        """
        return _IMP_domino.RestraintCache_save_cache(self, *args)

    def load_cache(self, *args):
        """load_cache(RestraintCache self, IMP::kernel::ParticlesTemp const & ps, ConstGroup group)"""
        return _IMP_domino.RestraintCache_load_cache(self, *args)

    def get_slice(self, *args):
        """get_slice(RestraintCache self, Restraint r, Subset s) -> Slice"""
        return _IMP_domino.RestraintCache_get_slice(self, *args)

    def get_number_of_entries(self):
        """get_number_of_entries(RestraintCache self) -> unsigned int"""
        return _IMP_domino.RestraintCache_get_number_of_entries(self)

    def validate(self):
        """validate(RestraintCache self)"""
        return _IMP_domino.RestraintCache_validate(self)

    def show_restraint_information(self, *args):
        """
        show_restraint_information(RestraintCache self, _ostream out=std::cout)
        show_restraint_information(RestraintCache self)
        """
        return _IMP_domino.RestraintCache_show_restraint_information(self, *args)

    def get_hit_rate(self):
        """get_hit_rate(RestraintCache self) -> double"""
        return _IMP_domino.RestraintCache_get_hit_rate(self)

    def get_version_info(self):
        """get_version_info(RestraintCache self) -> VersionInfo"""
        return _IMP_domino.RestraintCache_get_version_info(self)

    def __str__(self):
        """__str__(RestraintCache self) -> std::string"""
        return _IMP_domino.RestraintCache___str__(self)

    def __repr__(self):
        """__repr__(RestraintCache self) -> std::string"""
        return _IMP_domino.RestraintCache___repr__(self)

    def get_from(o):
       return _object_cast_to_RestraintCache(o)
    get_from = staticmethod(get_from)

RestraintCache_swigregister = _IMP_domino.RestraintCache_swigregister
RestraintCache_swigregister(RestraintCache)

class SubsetFilter(IMP.base.Object):
    """Proxy of C++ IMP::domino::SubsetFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubsetFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SubsetFilter, name)
    def __init__(self, name="SubsetFilter%1%"): 
        """
        __init__(IMP::domino::SubsetFilter self, std::string name="SubsetFilter%1%") -> SubsetFilter
        __init__(IMP::domino::SubsetFilter self) -> SubsetFilter
        """
        if self.__class__ == SubsetFilter:
            _self = None
        else:
            _self = self
        this = _IMP_domino.new_SubsetFilter(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != SubsetFilter:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_is_ok(self, *args):
        """get_is_ok(SubsetFilter self, Assignment state) -> bool"""
        return _IMP_domino.SubsetFilter_get_is_ok(self, *args)

    def get_next_state(self, *args):
        """get_next_state(SubsetFilter self, int pos, Assignment state) -> int"""
        return _IMP_domino.SubsetFilter_get_next_state(self, *args)

    __swig_destroy__ = _IMP_domino.delete_SubsetFilter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SubsetFilter self) -> std::string"""
        return _IMP_domino.SubsetFilter___str__(self)

    def __repr__(self):
        """__repr__(SubsetFilter self) -> std::string"""
        return _IMP_domino.SubsetFilter___repr__(self)

    def get_from(o):
       return _object_cast_to_SubsetFilter(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::domino" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_SubsetFilter(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_SubsetFilter(self)
        return weakref_proxy(self)
SubsetFilter_swigregister = _IMP_domino.SubsetFilter_swigregister
SubsetFilter_swigregister(SubsetFilter)

class SubsetFilterTable(IMP.base.Object):
    """Proxy of C++ IMP::domino::SubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SubsetFilterTable, name)
    def __init__(self, name="SubsetFilterTable%1%"): 
        """
        __init__(IMP::domino::SubsetFilterTable self, std::string name="SubsetFilterTable%1%") -> SubsetFilterTable
        __init__(IMP::domino::SubsetFilterTable self) -> SubsetFilterTable
        """
        if self.__class__ == SubsetFilterTable:
            _self = None
        else:
            _self = self
        this = _IMP_domino.new_SubsetFilterTable(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != SubsetFilterTable:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_subset_filter(self, *args):
        """get_subset_filter(SubsetFilterTable self, Subset s, IMP::domino::Subsets const & prior_subsets) -> SubsetFilter"""
        return _IMP_domino.SubsetFilterTable_get_subset_filter(self, *args)

    def get_strength(self, *args):
        """get_strength(SubsetFilterTable self, Subset s, IMP::domino::Subsets const & prior_subsets) -> double"""
        return _IMP_domino.SubsetFilterTable_get_strength(self, *args)

    __swig_destroy__ = _IMP_domino.delete_SubsetFilterTable
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SubsetFilterTable self) -> std::string"""
        return _IMP_domino.SubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(SubsetFilterTable self) -> std::string"""
        return _IMP_domino.SubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_SubsetFilterTable(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::domino" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_SubsetFilterTable(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_SubsetFilterTable(self)
        return weakref_proxy(self)
SubsetFilterTable_swigregister = _IMP_domino.SubsetFilterTable_swigregister
SubsetFilterTable_swigregister(SubsetFilterTable)

class RestraintScoreSubsetFilterTable(SubsetFilterTable):
    """Proxy of C++ IMP::domino::RestraintScoreSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintScoreSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintScoreSubsetFilterTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::RestraintScoreSubsetFilterTable self, RestraintCache rc) -> RestraintScoreSubsetFilterTable
        __init__(IMP::domino::RestraintScoreSubsetFilterTable self, _RestraintsAdaptor rs, ParticleStatesTable pst) -> RestraintScoreSubsetFilterTable
        """
        this = _IMP_domino.new_RestraintScoreSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RestraintScoreSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.RestraintScoreSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(RestraintScoreSubsetFilterTable self) -> std::string"""
        return _IMP_domino.RestraintScoreSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(RestraintScoreSubsetFilterTable self) -> std::string"""
        return _IMP_domino.RestraintScoreSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_RestraintScoreSubsetFilterTable(o)
    get_from = staticmethod(get_from)

RestraintScoreSubsetFilterTable_swigregister = _IMP_domino.RestraintScoreSubsetFilterTable_swigregister
RestraintScoreSubsetFilterTable_swigregister(RestraintScoreSubsetFilterTable)

class MinimumRestraintScoreSubsetFilterTable(SubsetFilterTable):
    """Proxy of C++ IMP::domino::MinimumRestraintScoreSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumRestraintScoreSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumRestraintScoreSubsetFilterTable, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::MinimumRestraintScoreSubsetFilterTable self, IMP::kernel::RestraintsTemp const & rs, RestraintCache rc, int max_number_allowed_violations) -> MinimumRestraintScoreSubsetFilterTable"""
        this = _IMP_domino.new_MinimumRestraintScoreSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_maximum_number_of_violated_restraints(self):
        """get_maximum_number_of_violated_restraints(MinimumRestraintScoreSubsetFilterTable self) -> int"""
        return _IMP_domino.MinimumRestraintScoreSubsetFilterTable_get_maximum_number_of_violated_restraints(self)

    def get_version_info(self):
        """get_version_info(MinimumRestraintScoreSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.MinimumRestraintScoreSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(MinimumRestraintScoreSubsetFilterTable self) -> std::string"""
        return _IMP_domino.MinimumRestraintScoreSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(MinimumRestraintScoreSubsetFilterTable self) -> std::string"""
        return _IMP_domino.MinimumRestraintScoreSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_MinimumRestraintScoreSubsetFilterTable(o)
    get_from = staticmethod(get_from)

MinimumRestraintScoreSubsetFilterTable_swigregister = _IMP_domino.MinimumRestraintScoreSubsetFilterTable_swigregister
MinimumRestraintScoreSubsetFilterTable_swigregister(MinimumRestraintScoreSubsetFilterTable)

class DisjointSetsSubsetFilterTable(SubsetFilterTable):
    """Proxy of C++ IMP::domino::DisjointSetsSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DisjointSetsSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DisjointSetsSubsetFilterTable, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def add_set(self, *args):
        """add_set(DisjointSetsSubsetFilterTable self, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_domino.DisjointSetsSubsetFilterTable_add_set(self, *args)

    def add_pair(self, *args):
        """add_pair(DisjointSetsSubsetFilterTable self, IMP::kernel::ParticlePair const & pp)"""
        return _IMP_domino.DisjointSetsSubsetFilterTable_add_pair(self, *args)

    def __str__(self):
        """__str__(DisjointSetsSubsetFilterTable self) -> std::string"""
        return _IMP_domino.DisjointSetsSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(DisjointSetsSubsetFilterTable self) -> std::string"""
        return _IMP_domino.DisjointSetsSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_DisjointSetsSubsetFilterTable(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_domino.delete_DisjointSetsSubsetFilterTable
    __del__ = lambda self : None;
DisjointSetsSubsetFilterTable_swigregister = _IMP_domino.DisjointSetsSubsetFilterTable_swigregister
DisjointSetsSubsetFilterTable_swigregister(DisjointSetsSubsetFilterTable)

class ExclusionSubsetFilterTable(DisjointSetsSubsetFilterTable):
    """Proxy of C++ IMP::domino::ExclusionSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExclusionSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExclusionSubsetFilterTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::ExclusionSubsetFilterTable self, ParticleStatesTable pst) -> ExclusionSubsetFilterTable
        __init__(IMP::domino::ExclusionSubsetFilterTable self) -> ExclusionSubsetFilterTable
        """
        this = _IMP_domino.new_ExclusionSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ExclusionSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.ExclusionSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(ExclusionSubsetFilterTable self) -> std::string"""
        return _IMP_domino.ExclusionSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(ExclusionSubsetFilterTable self) -> std::string"""
        return _IMP_domino.ExclusionSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_ExclusionSubsetFilterTable(o)
    get_from = staticmethod(get_from)

ExclusionSubsetFilterTable_swigregister = _IMP_domino.ExclusionSubsetFilterTable_swigregister
ExclusionSubsetFilterTable_swigregister(ExclusionSubsetFilterTable)

class EqualitySubsetFilterTable(DisjointSetsSubsetFilterTable):
    """Proxy of C++ IMP::domino::EqualitySubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EqualitySubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EqualitySubsetFilterTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::EqualitySubsetFilterTable self, ParticleStatesTable pst) -> EqualitySubsetFilterTable
        __init__(IMP::domino::EqualitySubsetFilterTable self) -> EqualitySubsetFilterTable
        """
        this = _IMP_domino.new_EqualitySubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EqualitySubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.EqualitySubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(EqualitySubsetFilterTable self) -> std::string"""
        return _IMP_domino.EqualitySubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(EqualitySubsetFilterTable self) -> std::string"""
        return _IMP_domino.EqualitySubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_EqualitySubsetFilterTable(o)
    get_from = staticmethod(get_from)

EqualitySubsetFilterTable_swigregister = _IMP_domino.EqualitySubsetFilterTable_swigregister
EqualitySubsetFilterTable_swigregister(EqualitySubsetFilterTable)

class EquivalenceSubsetFilterTable(DisjointSetsSubsetFilterTable):
    """Proxy of C++ IMP::domino::EquivalenceSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EquivalenceSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EquivalenceSubsetFilterTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::EquivalenceSubsetFilterTable self, ParticleStatesTable pst) -> EquivalenceSubsetFilterTable
        __init__(IMP::domino::EquivalenceSubsetFilterTable self) -> EquivalenceSubsetFilterTable
        """
        this = _IMP_domino.new_EquivalenceSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EquivalenceSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.EquivalenceSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(EquivalenceSubsetFilterTable self) -> std::string"""
        return _IMP_domino.EquivalenceSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(EquivalenceSubsetFilterTable self) -> std::string"""
        return _IMP_domino.EquivalenceSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_EquivalenceSubsetFilterTable(o)
    get_from = staticmethod(get_from)

EquivalenceSubsetFilterTable_swigregister = _IMP_domino.EquivalenceSubsetFilterTable_swigregister
EquivalenceSubsetFilterTable_swigregister(EquivalenceSubsetFilterTable)

class EquivalenceAndExclusionSubsetFilterTable(DisjointSetsSubsetFilterTable):
    """Proxy of C++ IMP::domino::EquivalenceAndExclusionSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EquivalenceAndExclusionSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [DisjointSetsSubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EquivalenceAndExclusionSubsetFilterTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::EquivalenceAndExclusionSubsetFilterTable self, ParticleStatesTable pst) -> EquivalenceAndExclusionSubsetFilterTable
        __init__(IMP::domino::EquivalenceAndExclusionSubsetFilterTable self) -> EquivalenceAndExclusionSubsetFilterTable
        """
        this = _IMP_domino.new_EquivalenceAndExclusionSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EquivalenceAndExclusionSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(EquivalenceAndExclusionSubsetFilterTable self) -> std::string"""
        return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(EquivalenceAndExclusionSubsetFilterTable self) -> std::string"""
        return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_EquivalenceAndExclusionSubsetFilterTable(o)
    get_from = staticmethod(get_from)

EquivalenceAndExclusionSubsetFilterTable_swigregister = _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_swigregister
EquivalenceAndExclusionSubsetFilterTable_swigregister(EquivalenceAndExclusionSubsetFilterTable)

class ListSubsetFilterTable(SubsetFilterTable):
    """Proxy of C++ IMP::domino::ListSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListSubsetFilterTable, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::ListSubsetFilterTable self, ParticleStatesTable pst) -> ListSubsetFilterTable"""
        this = _IMP_domino.new_ListSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_ok_rate(self):
        """get_ok_rate(ListSubsetFilterTable self) -> double"""
        return _IMP_domino.ListSubsetFilterTable_get_ok_rate(self)

    def get_number_of_particle_states(self, *args):
        """get_number_of_particle_states(ListSubsetFilterTable self, Particle p) -> unsigned int"""
        return _IMP_domino.ListSubsetFilterTable_get_number_of_particle_states(self, *args)

    def set_allowed_states(self, *args):
        """set_allowed_states(ListSubsetFilterTable self, Particle p, IMP::Ints const & states)"""
        return _IMP_domino.ListSubsetFilterTable_set_allowed_states(self, *args)

    def get_version_info(self):
        """get_version_info(ListSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.ListSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(ListSubsetFilterTable self) -> std::string"""
        return _IMP_domino.ListSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(ListSubsetFilterTable self) -> std::string"""
        return _IMP_domino.ListSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_ListSubsetFilterTable(o)
    get_from = staticmethod(get_from)

ListSubsetFilterTable_swigregister = _IMP_domino.ListSubsetFilterTable_swigregister
ListSubsetFilterTable_swigregister(ListSubsetFilterTable)

class PairListSubsetFilterTable(SubsetFilterTable):
    """Proxy of C++ IMP::domino::PairListSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairListSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairListSubsetFilterTable, name)
    def __init__(self): 
        """__init__(IMP::domino::PairListSubsetFilterTable self) -> PairListSubsetFilterTable"""
        this = _IMP_domino.new_PairListSubsetFilterTable()
        try: self.this.append(this)
        except: self.this = this
    def set_allowed_states(self, *args):
        """set_allowed_states(PairListSubsetFilterTable self, IMP::kernel::ParticlePair p, IMP::IntPairs const & states)"""
        return _IMP_domino.PairListSubsetFilterTable_set_allowed_states(self, *args)

    def get_version_info(self):
        """get_version_info(PairListSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.PairListSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(PairListSubsetFilterTable self) -> std::string"""
        return _IMP_domino.PairListSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(PairListSubsetFilterTable self) -> std::string"""
        return _IMP_domino.PairListSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_PairListSubsetFilterTable(o)
    get_from = staticmethod(get_from)

PairListSubsetFilterTable_swigregister = _IMP_domino.PairListSubsetFilterTable_swigregister
PairListSubsetFilterTable_swigregister(PairListSubsetFilterTable)

class ProbabilisticSubsetFilterTable(SubsetFilterTable):
    """Proxy of C++ IMP::domino::ProbabilisticSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProbabilisticSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProbabilisticSubsetFilterTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::ProbabilisticSubsetFilterTable self, double p, bool leaves_only=False) -> ProbabilisticSubsetFilterTable
        __init__(IMP::domino::ProbabilisticSubsetFilterTable self, double p) -> ProbabilisticSubsetFilterTable
        """
        this = _IMP_domino.new_ProbabilisticSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ProbabilisticSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.ProbabilisticSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(ProbabilisticSubsetFilterTable self) -> std::string"""
        return _IMP_domino.ProbabilisticSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(ProbabilisticSubsetFilterTable self) -> std::string"""
        return _IMP_domino.ProbabilisticSubsetFilterTable___repr__(self)

    def get_from(o):
       return _object_cast_to_ProbabilisticSubsetFilterTable(o)
    get_from = staticmethod(get_from)

ProbabilisticSubsetFilterTable_swigregister = _IMP_domino.ProbabilisticSubsetFilterTable_swigregister
ProbabilisticSubsetFilterTable_swigregister(ProbabilisticSubsetFilterTable)

class AssignmentContainer(IMP.base.Object):
    """Proxy of C++ IMP::domino::AssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AssignmentContainer, name)
    def __init__(self, name="AssignmentsContainer %1%"): 
        """
        __init__(IMP::domino::AssignmentContainer self, std::string name="AssignmentsContainer %1%") -> AssignmentContainer
        __init__(IMP::domino::AssignmentContainer self) -> AssignmentContainer
        """
        if self.__class__ == AssignmentContainer:
            _self = None
        else:
            _self = self
        this = _IMP_domino.new_AssignmentContainer(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != AssignmentContainer:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_number_of_assignments(self):
        """get_number_of_assignments(AssignmentContainer self) -> unsigned int"""
        return _IMP_domino.AssignmentContainer_get_number_of_assignments(self)

    def get_assignment(self, *args):
        """get_assignment(AssignmentContainer self, unsigned int i) -> Assignment"""
        return _IMP_domino.AssignmentContainer_get_assignment(self, *args)

    def get_assignments(self, *args):
        """
        get_assignments(AssignmentContainer self, IMP::IntRange ir) -> IMP::domino::Assignments
        get_assignments(AssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.AssignmentContainer_get_assignments(self, *args)

    def add_assignment(self, *args):
        """add_assignment(AssignmentContainer self, Assignment a)"""
        return _IMP_domino.AssignmentContainer_add_assignment(self, *args)

    def add_assignments(self, *args):
        """add_assignments(AssignmentContainer self, IMP::domino::Assignments const & as)"""
        return _IMP_domino.AssignmentContainer_add_assignments(self, *args)

    def get_particle_assignments(self, *args):
        """get_particle_assignments(AssignmentContainer self, unsigned int i) -> IMP::Ints"""
        return _IMP_domino.AssignmentContainer_get_particle_assignments(self, *args)

    __swig_destroy__ = _IMP_domino.delete_AssignmentContainer
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AssignmentContainer self) -> std::string"""
        return _IMP_domino.AssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(AssignmentContainer self) -> std::string"""
        return _IMP_domino.AssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_AssignmentContainer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::domino" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_AssignmentContainer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_AssignmentContainer(self)
        return weakref_proxy(self)
AssignmentContainer_swigregister = _IMP_domino.AssignmentContainer_swigregister
AssignmentContainer_swigregister(AssignmentContainer)

class PackedAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::PackedAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedAssignmentContainer, name)
    def __init__(self, name="PackedAssignmentsContainer %1%"): 
        """
        __init__(IMP::domino::PackedAssignmentContainer self, std::string name="PackedAssignmentsContainer %1%") -> PackedAssignmentContainer
        __init__(IMP::domino::PackedAssignmentContainer self) -> PackedAssignmentContainer
        """
        this = _IMP_domino.new_PackedAssignmentContainer(name)
        try: self.this.append(this)
        except: self.this = this
    def get_assignments(self, *args):
        """
        get_assignments(PackedAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(PackedAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.PackedAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(PackedAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.PackedAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(PackedAssignmentContainer self) -> std::string"""
        return _IMP_domino.PackedAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(PackedAssignmentContainer self) -> std::string"""
        return _IMP_domino.PackedAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_PackedAssignmentContainer(o)
    get_from = staticmethod(get_from)

PackedAssignmentContainer_swigregister = _IMP_domino.PackedAssignmentContainer_swigregister
PackedAssignmentContainer_swigregister(PackedAssignmentContainer)

class ListAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::ListAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListAssignmentContainer, name)
    def __init__(self, name="ListAssignmentsContainer %1%"): 
        """
        __init__(IMP::domino::ListAssignmentContainer self, std::string name="ListAssignmentsContainer %1%") -> ListAssignmentContainer
        __init__(IMP::domino::ListAssignmentContainer self) -> ListAssignmentContainer
        """
        this = _IMP_domino.new_ListAssignmentContainer(name)
        try: self.this.append(this)
        except: self.this = this
    def get_assignments(self, *args):
        """
        get_assignments(ListAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(ListAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.ListAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(ListAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.ListAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(ListAssignmentContainer self) -> std::string"""
        return _IMP_domino.ListAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(ListAssignmentContainer self) -> std::string"""
        return _IMP_domino.ListAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ListAssignmentContainer(o)
    get_from = staticmethod(get_from)

ListAssignmentContainer_swigregister = _IMP_domino.ListAssignmentContainer_swigregister
ListAssignmentContainer_swigregister(ListAssignmentContainer)

class SampleAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::SampleAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SampleAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SampleAssignmentContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::SampleAssignmentContainer self, unsigned int k, std::string name="SampleAssignmentsContainer %1%") -> SampleAssignmentContainer
        __init__(IMP::domino::SampleAssignmentContainer self, unsigned int k) -> SampleAssignmentContainer
        """
        this = _IMP_domino.new_SampleAssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_assignments(self, *args):
        """
        get_assignments(SampleAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(SampleAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.SampleAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(SampleAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.SampleAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(SampleAssignmentContainer self) -> std::string"""
        return _IMP_domino.SampleAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(SampleAssignmentContainer self) -> std::string"""
        return _IMP_domino.SampleAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_SampleAssignmentContainer(o)
    get_from = staticmethod(get_from)

SampleAssignmentContainer_swigregister = _IMP_domino.SampleAssignmentContainer_swigregister
SampleAssignmentContainer_swigregister(SampleAssignmentContainer)

class WriteHDF5AssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::WriteHDF5AssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriteHDF5AssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriteHDF5AssignmentContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::WriteHDF5AssignmentContainer self, Group parent, Subset s, IMP::kernel::ParticlesTemp const & all_particles, std::string name) -> WriteHDF5AssignmentContainer
        __init__(IMP::domino::WriteHDF5AssignmentContainer self, IndexDataSet2D dataset, Subset s, IMP::kernel::ParticlesTemp const & all_particles, 
            std::string name) -> WriteHDF5AssignmentContainer
        """
        this = _IMP_domino.new_WriteHDF5AssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_cache_size(self, *args):
        """set_cache_size(WriteHDF5AssignmentContainer self, unsigned int words)"""
        return _IMP_domino.WriteHDF5AssignmentContainer_set_cache_size(self, *args)

    def get_assignments(self, *args):
        """
        get_assignments(WriteHDF5AssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(WriteHDF5AssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.WriteHDF5AssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(WriteHDF5AssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.WriteHDF5AssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(WriteHDF5AssignmentContainer self) -> std::string"""
        return _IMP_domino.WriteHDF5AssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(WriteHDF5AssignmentContainer self) -> std::string"""
        return _IMP_domino.WriteHDF5AssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_WriteHDF5AssignmentContainer(o)
    get_from = staticmethod(get_from)

WriteHDF5AssignmentContainer_swigregister = _IMP_domino.WriteHDF5AssignmentContainer_swigregister
WriteHDF5AssignmentContainer_swigregister(WriteHDF5AssignmentContainer)

class ReadHDF5AssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::ReadHDF5AssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReadHDF5AssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReadHDF5AssignmentContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::ReadHDF5AssignmentContainer self, IndexConstDataSet2D dataset, Subset s, IMP::kernel::ParticlesTemp const & all_particles, 
            std::string name) -> ReadHDF5AssignmentContainer
        """
        this = _IMP_domino.new_ReadHDF5AssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_cache_size(self, *args):
        """set_cache_size(ReadHDF5AssignmentContainer self, unsigned int words)"""
        return _IMP_domino.ReadHDF5AssignmentContainer_set_cache_size(self, *args)

    def get_assignments(self, *args):
        """
        get_assignments(ReadHDF5AssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(ReadHDF5AssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.ReadHDF5AssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(ReadHDF5AssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.ReadHDF5AssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(ReadHDF5AssignmentContainer self) -> std::string"""
        return _IMP_domino.ReadHDF5AssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(ReadHDF5AssignmentContainer self) -> std::string"""
        return _IMP_domino.ReadHDF5AssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ReadHDF5AssignmentContainer(o)
    get_from = staticmethod(get_from)

ReadHDF5AssignmentContainer_swigregister = _IMP_domino.ReadHDF5AssignmentContainer_swigregister
ReadHDF5AssignmentContainer_swigregister(ReadHDF5AssignmentContainer)

class WriteAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::WriteAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriteAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriteAssignmentContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::WriteAssignmentContainer self, std::string out_file, Subset s, IMP::kernel::ParticlesTemp const & all_particles, 
            std::string name) -> WriteAssignmentContainer
        """
        this = _IMP_domino.new_WriteAssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_cache_size(self, *args):
        """set_cache_size(WriteAssignmentContainer self, unsigned int words)"""
        return _IMP_domino.WriteAssignmentContainer_set_cache_size(self, *args)

    def get_assignments(self, *args):
        """
        get_assignments(WriteAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(WriteAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.WriteAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(WriteAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.WriteAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(WriteAssignmentContainer self) -> std::string"""
        return _IMP_domino.WriteAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(WriteAssignmentContainer self) -> std::string"""
        return _IMP_domino.WriteAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_WriteAssignmentContainer(o)
    get_from = staticmethod(get_from)

WriteAssignmentContainer_swigregister = _IMP_domino.WriteAssignmentContainer_swigregister
WriteAssignmentContainer_swigregister(WriteAssignmentContainer)

class ReadAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::ReadAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReadAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReadAssignmentContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::ReadAssignmentContainer self, std::string out_file, Subset s, IMP::kernel::ParticlesTemp const & all_particles, 
            std::string name) -> ReadAssignmentContainer
        """
        this = _IMP_domino.new_ReadAssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_cache_size(self, *args):
        """set_cache_size(ReadAssignmentContainer self, unsigned int words)"""
        return _IMP_domino.ReadAssignmentContainer_set_cache_size(self, *args)

    def get_assignments(self, *args):
        """
        get_assignments(ReadAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(ReadAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.ReadAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(ReadAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.ReadAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(ReadAssignmentContainer self) -> std::string"""
        return _IMP_domino.ReadAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(ReadAssignmentContainer self) -> std::string"""
        return _IMP_domino.ReadAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_ReadAssignmentContainer(o)
    get_from = staticmethod(get_from)

ReadAssignmentContainer_swigregister = _IMP_domino.ReadAssignmentContainer_swigregister
ReadAssignmentContainer_swigregister(ReadAssignmentContainer)

class RangeViewAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::RangeViewAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RangeViewAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RangeViewAssignmentContainer, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::RangeViewAssignmentContainer self, AssignmentContainer inner, unsigned int begin, unsigned int end) -> RangeViewAssignmentContainer"""
        this = _IMP_domino.new_RangeViewAssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_assignments(self, *args):
        """
        get_assignments(RangeViewAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(RangeViewAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.RangeViewAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(RangeViewAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.RangeViewAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(RangeViewAssignmentContainer self) -> std::string"""
        return _IMP_domino.RangeViewAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(RangeViewAssignmentContainer self) -> std::string"""
        return _IMP_domino.RangeViewAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_RangeViewAssignmentContainer(o)
    get_from = staticmethod(get_from)

RangeViewAssignmentContainer_swigregister = _IMP_domino.RangeViewAssignmentContainer_swigregister
RangeViewAssignmentContainer_swigregister(RangeViewAssignmentContainer)

class HeapAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::HeapAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HeapAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HeapAssignmentContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::HeapAssignmentContainer self, Subset subset, unsigned int k, RestraintCache rssf, std::string name="HeapAssignmentsContainer %1%") -> HeapAssignmentContainer
        __init__(IMP::domino::HeapAssignmentContainer self, Subset subset, unsigned int k, RestraintCache rssf) -> HeapAssignmentContainer
        """
        this = _IMP_domino.new_HeapAssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_assignments(self, *args):
        """
        get_assignments(HeapAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(HeapAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.HeapAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(HeapAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.HeapAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(HeapAssignmentContainer self) -> std::string"""
        return _IMP_domino.HeapAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(HeapAssignmentContainer self) -> std::string"""
        return _IMP_domino.HeapAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_HeapAssignmentContainer(o)
    get_from = staticmethod(get_from)

HeapAssignmentContainer_swigregister = _IMP_domino.HeapAssignmentContainer_swigregister
HeapAssignmentContainer_swigregister(HeapAssignmentContainer)

class CappedAssignmentContainer(AssignmentContainer):
    """Proxy of C++ IMP::domino::CappedAssignmentContainer class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CappedAssignmentContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CappedAssignmentContainer, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::CappedAssignmentContainer self, AssignmentContainer contained, int max_states, std::string name) -> CappedAssignmentContainer"""
        this = _IMP_domino.new_CappedAssignmentContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_assignments(self, *args):
        """
        get_assignments(CappedAssignmentContainer self, IMP::IntRange r) -> IMP::domino::Assignments
        get_assignments(CappedAssignmentContainer self) -> IMP::domino::Assignments
        """
        return _IMP_domino.CappedAssignmentContainer_get_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(CappedAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.CappedAssignmentContainer_get_version_info(self)

    def __str__(self):
        """__str__(CappedAssignmentContainer self) -> std::string"""
        return _IMP_domino.CappedAssignmentContainer___str__(self)

    def __repr__(self):
        """__repr__(CappedAssignmentContainer self) -> std::string"""
        return _IMP_domino.CappedAssignmentContainer___repr__(self)

    def get_from(o):
       return _object_cast_to_CappedAssignmentContainer(o)
    get_from = staticmethod(get_from)

CappedAssignmentContainer_swigregister = _IMP_domino.CappedAssignmentContainer_swigregister
CappedAssignmentContainer_swigregister(CappedAssignmentContainer)

class AssignmentsTable(IMP.base.Object):
    """Proxy of C++ IMP::domino::AssignmentsTable class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AssignmentsTable, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AssignmentsTable, name)
    def __init__(self, name="SubsetStatesTable %1%"): 
        """
        __init__(IMP::domino::AssignmentsTable self, std::string name="SubsetStatesTable %1%") -> AssignmentsTable
        __init__(IMP::domino::AssignmentsTable self) -> AssignmentsTable
        """
        if self.__class__ == AssignmentsTable:
            _self = None
        else:
            _self = self
        this = _IMP_domino.new_AssignmentsTable(_self, name)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != AssignmentsTable:
            import IMP.base
            IMP.base._director_objects.register(self)



    def load_assignments(self, *args):
        """load_assignments(AssignmentsTable self, Subset s, AssignmentContainer ac)"""
        return _IMP_domino.AssignmentsTable_load_assignments(self, *args)

    __swig_destroy__ = _IMP_domino.delete_AssignmentsTable
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(AssignmentsTable self) -> std::string"""
        return _IMP_domino.AssignmentsTable___str__(self)

    def __repr__(self):
        """__repr__(AssignmentsTable self) -> std::string"""
        return _IMP_domino.AssignmentsTable___repr__(self)

    def get_from(o):
       return _object_cast_to_AssignmentsTable(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::domino" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_AssignmentsTable(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_AssignmentsTable(self)
        return weakref_proxy(self)
AssignmentsTable_swigregister = _IMP_domino.AssignmentsTable_swigregister
AssignmentsTable_swigregister(AssignmentsTable)

class SimpleAssignmentsTable(AssignmentsTable):
    """Proxy of C++ IMP::domino::SimpleAssignmentsTable class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleAssignmentsTable, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleAssignmentsTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::SimpleAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(), 
            unsigned int max=std::numeric_limits< unsigned int >::max()) -> SimpleAssignmentsTable
        __init__(IMP::domino::SimpleAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables()) -> SimpleAssignmentsTable
        __init__(IMP::domino::SimpleAssignmentsTable self, ParticleStatesTable pst) -> SimpleAssignmentsTable
        """
        this = _IMP_domino.new_SimpleAssignmentsTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(SimpleAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.SimpleAssignmentsTable_get_version_info(self)

    def __str__(self):
        """__str__(SimpleAssignmentsTable self) -> std::string"""
        return _IMP_domino.SimpleAssignmentsTable___str__(self)

    def __repr__(self):
        """__repr__(SimpleAssignmentsTable self) -> std::string"""
        return _IMP_domino.SimpleAssignmentsTable___repr__(self)

    def get_from(o):
       return _object_cast_to_SimpleAssignmentsTable(o)
    get_from = staticmethod(get_from)

SimpleAssignmentsTable_swigregister = _IMP_domino.SimpleAssignmentsTable_swigregister
SimpleAssignmentsTable_swigregister(SimpleAssignmentsTable)

class RecursiveAssignmentsTable(AssignmentsTable):
    """Proxy of C++ IMP::domino::RecursiveAssignmentsTable class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RecursiveAssignmentsTable, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RecursiveAssignmentsTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::RecursiveAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(), 
            unsigned int max=std::numeric_limits< unsigned int >::max()) -> RecursiveAssignmentsTable
        __init__(IMP::domino::RecursiveAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables()) -> RecursiveAssignmentsTable
        __init__(IMP::domino::RecursiveAssignmentsTable self, ParticleStatesTable pst) -> RecursiveAssignmentsTable
        """
        this = _IMP_domino.new_RecursiveAssignmentsTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(RecursiveAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.RecursiveAssignmentsTable_get_version_info(self)

    def __str__(self):
        """__str__(RecursiveAssignmentsTable self) -> std::string"""
        return _IMP_domino.RecursiveAssignmentsTable___str__(self)

    def __repr__(self):
        """__repr__(RecursiveAssignmentsTable self) -> std::string"""
        return _IMP_domino.RecursiveAssignmentsTable___repr__(self)

    def get_from(o):
       return _object_cast_to_RecursiveAssignmentsTable(o)
    get_from = staticmethod(get_from)

RecursiveAssignmentsTable_swigregister = _IMP_domino.RecursiveAssignmentsTable_swigregister
RecursiveAssignmentsTable_swigregister(RecursiveAssignmentsTable)

class BranchAndBoundAssignmentsTable(AssignmentsTable):
    """Proxy of C++ IMP::domino::BranchAndBoundAssignmentsTable class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BranchAndBoundAssignmentsTable, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BranchAndBoundAssignmentsTable, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::BranchAndBoundAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(), 
            unsigned int max=std::numeric_limits< unsigned int >::max()) -> BranchAndBoundAssignmentsTable
        __init__(IMP::domino::BranchAndBoundAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables()) -> BranchAndBoundAssignmentsTable
        __init__(IMP::domino::BranchAndBoundAssignmentsTable self, ParticleStatesTable pst) -> BranchAndBoundAssignmentsTable
        """
        this = _IMP_domino.new_BranchAndBoundAssignmentsTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(BranchAndBoundAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.BranchAndBoundAssignmentsTable_get_version_info(self)

    def __str__(self):
        """__str__(BranchAndBoundAssignmentsTable self) -> std::string"""
        return _IMP_domino.BranchAndBoundAssignmentsTable___str__(self)

    def __repr__(self):
        """__repr__(BranchAndBoundAssignmentsTable self) -> std::string"""
        return _IMP_domino.BranchAndBoundAssignmentsTable___repr__(self)

    def get_from(o):
       return _object_cast_to_BranchAndBoundAssignmentsTable(o)
    get_from = staticmethod(get_from)

BranchAndBoundAssignmentsTable_swigregister = _IMP_domino.BranchAndBoundAssignmentsTable_swigregister
BranchAndBoundAssignmentsTable_swigregister(BranchAndBoundAssignmentsTable)

class ListAssignmentsTable(AssignmentsTable):
    """Proxy of C++ IMP::domino::ListAssignmentsTable class"""
    __swig_setmethods__ = {}
    for _s in [AssignmentsTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListAssignmentsTable, name, value)
    __swig_getmethods__ = {}
    for _s in [AssignmentsTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListAssignmentsTable, name)
    def __init__(self, name="ListSubsetStatesTable %1%"): 
        """
        __init__(IMP::domino::ListAssignmentsTable self, std::string name="ListSubsetStatesTable %1%") -> ListAssignmentsTable
        __init__(IMP::domino::ListAssignmentsTable self) -> ListAssignmentsTable
        """
        this = _IMP_domino.new_ListAssignmentsTable(name)
        try: self.this.append(this)
        except: self.this = this
    def set_assignments(self, *args):
        """set_assignments(ListAssignmentsTable self, Subset s, AssignmentContainer lsc)"""
        return _IMP_domino.ListAssignmentsTable_set_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(ListAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.ListAssignmentsTable_get_version_info(self)

    def __str__(self):
        """__str__(ListAssignmentsTable self) -> std::string"""
        return _IMP_domino.ListAssignmentsTable___str__(self)

    def __repr__(self):
        """__repr__(ListAssignmentsTable self) -> std::string"""
        return _IMP_domino.ListAssignmentsTable___repr__(self)

    def get_from(o):
       return _object_cast_to_ListAssignmentsTable(o)
    get_from = staticmethod(get_from)

ListAssignmentsTable_swigregister = _IMP_domino.ListAssignmentsTable_swigregister
ListAssignmentsTable_swigregister(ListAssignmentsTable)


def get_order(*args):
  """get_order(Subset s, IMP::domino::SubsetFilterTables const & sft) -> IMP::kernel::ParticlesTemp"""
  return _IMP_domino.get_order(*args)
class _SubsetGraphVertexIndex(_object):
    """Proxy of C++ IMP::domino::SubsetGraphVertexIndex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _SubsetGraphVertexIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _SubsetGraphVertexIndex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::domino::SubsetGraphVertexIndex self) -> _SubsetGraphVertexIndex"""
        this = _IMP_domino.new__SubsetGraphVertexIndex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_domino.delete__SubsetGraphVertexIndex
    __del__ = lambda self : None;
_SubsetGraphVertexIndex_swigregister = _IMP_domino._SubsetGraphVertexIndex_swigregister
_SubsetGraphVertexIndex_swigregister(_SubsetGraphVertexIndex)

class _InteractionGraphVertexIndex(_object):
    """Proxy of C++ IMP::domino::InteractionGraphVertexIndex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _InteractionGraphVertexIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _InteractionGraphVertexIndex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::domino::InteractionGraphVertexIndex self) -> _InteractionGraphVertexIndex"""
        this = _IMP_domino.new__InteractionGraphVertexIndex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_domino.delete__InteractionGraphVertexIndex
    __del__ = lambda self : None;
_InteractionGraphVertexIndex_swigregister = _IMP_domino._InteractionGraphVertexIndex_swigregister
_InteractionGraphVertexIndex_swigregister(_InteractionGraphVertexIndex)


def get_subsets(*args):
  """get_subsets(IMP::domino::SubsetGraph const & g) -> IMP::domino::Subsets"""
  return _IMP_domino.get_subsets(*args)

def get_junction_tree(*args):
  """get_junction_tree(IMP::domino::InteractionGraph const & ig) -> IMP::domino::SubsetGraph"""
  return _IMP_domino.get_junction_tree(*args)

def get_triangulated(*args):
  """get_triangulated(IMP::domino::InteractionGraph const & input) -> IMP::domino::InteractionGraph"""
  return _IMP_domino.get_triangulated(*args)
class _CliqueGraphVertexIndex(_object):
    """Proxy of C++ IMP::domino::CliqueGraphVertexIndex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _CliqueGraphVertexIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _CliqueGraphVertexIndex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::domino::CliqueGraphVertexIndex self) -> _CliqueGraphVertexIndex"""
        this = _IMP_domino.new__CliqueGraphVertexIndex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_domino.delete__CliqueGraphVertexIndex
    __del__ = lambda self : None;
_CliqueGraphVertexIndex_swigregister = _IMP_domino._CliqueGraphVertexIndex_swigregister
_CliqueGraphVertexIndex_swigregister(_CliqueGraphVertexIndex)


def get_clique_graph(*args):
  """get_clique_graph(IMP::domino::InteractionGraph const & input) -> IMP::domino::CliqueGraph"""
  return _IMP_domino.get_clique_graph(*args)

def get_minimum_spanning_tree(*args):
  """get_minimum_spanning_tree(IMP::domino::CliqueGraph const & input) -> IMP::domino::SubsetGraph"""
  return _IMP_domino.get_minimum_spanning_tree(*args)

def get_restraint_graph(*args):
  """get_restraint_graph(_ScoringFunctionAdaptor rs, ParticleStatesTable pst) -> IMP::domino::SubsetGraph"""
  return _IMP_domino.get_restraint_graph(*args)

def get_interaction_graph(*args):
  """
    get_interaction_graph(_ScoringFunctionAdaptor rs, ParticleStatesTable pst) -> IMP::domino::InteractionGraph
    get_interaction_graph(_ScoringFunctionAdaptor rs, IMP::kernel::ParticlesTemp const & pst) -> IMP::domino::InteractionGraph
    """
  return _IMP_domino.get_interaction_graph(*args)

def get_interaction_graph_geometry(*args):
  """get_interaction_graph_geometry(IMP::domino::InteractionGraph const & ig) -> IMP::display::Geometries"""
  return _IMP_domino.get_interaction_graph_geometry(*args)

def get_subset_graph_geometry(*args):
  """get_subset_graph_geometry(IMP::domino::SubsetGraph const & ig) -> IMP::display::Geometries"""
  return _IMP_domino.get_subset_graph_geometry(*args)
class _MergeTreeVertexIndex(_object):
    """Proxy of C++ IMP::domino::MergeTreeVertexIndex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _MergeTreeVertexIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _MergeTreeVertexIndex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::domino::MergeTreeVertexIndex self) -> _MergeTreeVertexIndex"""
        this = _IMP_domino.new__MergeTreeVertexIndex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_domino.delete__MergeTreeVertexIndex
    __del__ = lambda self : None;
_MergeTreeVertexIndex_swigregister = _IMP_domino._MergeTreeVertexIndex_swigregister
_MergeTreeVertexIndex_swigregister(_MergeTreeVertexIndex)


def show_as_graphviz(*args):
  """
    show_as_graphviz(IMP::domino::SubsetGraph const & name, TextOutput out)
    show_as_graphviz(IMP::domino::InteractionGraph const & name, TextOutput out)
    show_as_graphviz(IMP::domino::CliqueGraph const & name, TextOutput out)
    show_as_graphviz(IMP::domino::MergeTree const & name, TextOutput out)
    """
  return _IMP_domino.show_as_graphviz(*args)

def get_vertex_index(*args):
  """
    get_vertex_index(IMP::domino::SubsetGraph const & g) -> _SubsetGraphVertexIndex
    get_vertex_index(IMP::domino::InteractionGraph const & g) -> _InteractionGraphVertexIndex
    get_vertex_index(IMP::domino::CliqueGraph const & g) -> _CliqueGraphVertexIndex
    get_vertex_index(IMP::domino::MergeTree const & g) -> _MergeTreeVertexIndex
    """
  return _IMP_domino.get_vertex_index(*args)

def get_merge_tree(*args):
  """
    get_merge_tree(_ScoringFunctionAdaptor input, ParticleStatesTable pst) -> IMP::domino::MergeTree
    get_merge_tree(IMP::domino::SubsetGraph const & junction_tree) -> IMP::domino::MergeTree
    """
  return _IMP_domino.get_merge_tree(*args)

def get_balanced_merge_tree(*args):
  """get_balanced_merge_tree(IMP::domino::SubsetGraph const & junction_tree) -> IMP::domino::MergeTree"""
  return _IMP_domino.get_balanced_merge_tree(*args)

def get_is_merge_tree(*args):
  """
    get_is_merge_tree(IMP::domino::MergeTree const & tree, Subset all, bool verbose=True) -> bool
    get_is_merge_tree(IMP::domino::MergeTree const & tree, Subset all) -> bool
    """
  return _IMP_domino.get_is_merge_tree(*args)

def write_merge_tree(*args):
  """write_merge_tree(IMP::domino::MergeTree const & tree, IMP::kernel::ParticlesTemp const & ps, _ostream out)"""
  return _IMP_domino.write_merge_tree(*args)

def read_merge_tree(*args):
  """read_merge_tree(std::istream & input, IMP::kernel::ParticlesTemp const & ps) -> IMP::domino::MergeTree"""
  return _IMP_domino.read_merge_tree(*args)
class DiscreteSampler(IMP.kernel.Sampler):
    """Proxy of C++ IMP::domino::DiscreteSampler class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Sampler]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DiscreteSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Sampler]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DiscreteSampler, name)
    def get_subset_filter_tables_to_use(self, *args):
        """get_subset_filter_tables_to_use(DiscreteSampler self, IMP::kernel::RestraintsTemp const & rs, ParticleStatesTable pst) -> IMP::domino::SubsetFilterTables"""
        return _IMP_domino.DiscreteSampler_get_subset_filter_tables_to_use(self, *args)

    def get_assignments_table_to_use(self, *args):
        """
        get_assignments_table_to_use(DiscreteSampler self, IMP::domino::SubsetFilterTables const & sfts, unsigned int max=std::numeric_limits< int >::max()) -> AssignmentsTable
        get_assignments_table_to_use(DiscreteSampler self, IMP::domino::SubsetFilterTables const & sfts) -> AssignmentsTable
        """
        return _IMP_domino.DiscreteSampler_get_assignments_table_to_use(self, *args)

    def do_sample(self):
        """do_sample(DiscreteSampler self) -> ConfigurationSet"""
        return _IMP_domino.DiscreteSampler_do_sample(self)

    def do_get_sample_assignments(self, *args):
        """do_get_sample_assignments(DiscreteSampler self, Subset all) -> IMP::domino::Assignments"""
        return _IMP_domino.DiscreteSampler_do_get_sample_assignments(self, *args)

    def __init__(self, *args): 
        """__init__(IMP::domino::DiscreteSampler self, Model m, ParticleStatesTable pst, std::string name) -> DiscreteSampler"""
        if self.__class__ == DiscreteSampler:
            _self = None
        else:
            _self = self
        this = _IMP_domino.new_DiscreteSampler(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != DiscreteSampler:
            import IMP.base
            IMP.base._director_objects.register(self)



    __swig_destroy__ = _IMP_domino.delete_DiscreteSampler
    __del__ = lambda self : None;
    def set_particle_states(self, *args):
        """set_particle_states(DiscreteSampler self, Particle p, ParticleStates se)"""
        return _IMP_domino.DiscreteSampler_set_particle_states(self, *args)

    def get_sample_assignments(self, *args):
        """get_sample_assignments(DiscreteSampler self, Subset s) -> IMP::domino::Assignments"""
        return _IMP_domino.DiscreteSampler_get_sample_assignments(self, *args)

    def set_particle_states_table(self, *args):
        """set_particle_states_table(DiscreteSampler self, ParticleStatesTable cse)"""
        return _IMP_domino.DiscreteSampler_set_particle_states_table(self, *args)

    def set_assignments_table(self, *args):
        """set_assignments_table(DiscreteSampler self, AssignmentsTable sst)"""
        return _IMP_domino.DiscreteSampler_set_assignments_table(self, *args)

    def get_particle_states_table(self):
        """get_particle_states_table(DiscreteSampler self) -> ParticleStatesTable"""
        return _IMP_domino.DiscreteSampler_get_particle_states_table(self)

    def remove_subset_filter_table(self, *args):
        """remove_subset_filter_table(DiscreteSampler self, SubsetFilterTable d)"""
        return _IMP_domino.DiscreteSampler_remove_subset_filter_table(self, *args)

    def remove_subset_filter_tables(self, *args):
        """remove_subset_filter_tables(DiscreteSampler self, IMP::domino::SubsetFilterTables const & d)"""
        return _IMP_domino.DiscreteSampler_remove_subset_filter_tables(self, *args)

    def set_subset_filter_tables(self, *args):
        """set_subset_filter_tables(DiscreteSampler self, IMP::domino::SubsetFilterTables const & ps)"""
        return _IMP_domino.DiscreteSampler_set_subset_filter_tables(self, *args)

    def set_subset_filter_tables_order(self, *args):
        """set_subset_filter_tables_order(DiscreteSampler self, IMP::domino::SubsetFilterTables const & objs)"""
        return _IMP_domino.DiscreteSampler_set_subset_filter_tables_order(self, *args)

    def add_subset_filter_table(self, *args):
        """add_subset_filter_table(DiscreteSampler self, SubsetFilterTable obj) -> unsigned int"""
        return _IMP_domino.DiscreteSampler_add_subset_filter_table(self, *args)

    def add_subset_filter_tables(self, *args):
        """add_subset_filter_tables(DiscreteSampler self, IMP::domino::SubsetFilterTables const & objs)"""
        return _IMP_domino.DiscreteSampler_add_subset_filter_tables(self, *args)

    def clear_subset_filter_tables(self):
        """clear_subset_filter_tables(DiscreteSampler self)"""
        return _IMP_domino.DiscreteSampler_clear_subset_filter_tables(self)

    def get_number_of_subset_filter_tables(self):
        """get_number_of_subset_filter_tables(DiscreteSampler self) -> unsigned int"""
        return _IMP_domino.DiscreteSampler_get_number_of_subset_filter_tables(self)

    def get_has_subset_filter_tables(self):
        """get_has_subset_filter_tables(DiscreteSampler self) -> bool"""
        return _IMP_domino.DiscreteSampler_get_has_subset_filter_tables(self)

    def get_subset_filter_table(self, *args):
        """get_subset_filter_table(DiscreteSampler self, unsigned int i) -> SubsetFilterTable"""
        return _IMP_domino.DiscreteSampler_get_subset_filter_table(self, *args)

    def get_subset_filter_tables(self):
        """get_subset_filter_tables(DiscreteSampler self) -> IMP::domino::SubsetFilterTables"""
        return _IMP_domino.DiscreteSampler_get_subset_filter_tables(self)

    def reserve_subset_filter_tables(self, *args):
        """reserve_subset_filter_tables(DiscreteSampler self, unsigned int sz)"""
        return _IMP_domino.DiscreteSampler_reserve_subset_filter_tables(self, *args)

    def set_maximum_number_of_assignments(self, *args):
        """set_maximum_number_of_assignments(DiscreteSampler self, unsigned int mx)"""
        return _IMP_domino.DiscreteSampler_set_maximum_number_of_assignments(self, *args)

    def get_maximum_number_of_assignments(self):
        """get_maximum_number_of_assignments(DiscreteSampler self) -> unsigned int"""
        return _IMP_domino.DiscreteSampler_get_maximum_number_of_assignments(self)

    def __str__(self):
        """__str__(DiscreteSampler self) -> std::string"""
        return _IMP_domino.DiscreteSampler___str__(self)

    def __repr__(self):
        """__repr__(DiscreteSampler self) -> std::string"""
        return _IMP_domino.DiscreteSampler___repr__(self)

    def get_from(o):
       return _object_cast_to_DiscreteSampler(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::domino" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_DiscreteSampler(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_DiscreteSampler(self)
        return weakref_proxy(self)
DiscreteSampler_swigregister = _IMP_domino.DiscreteSampler_swigregister
DiscreteSampler_swigregister(DiscreteSampler)

class DominoSampler(DiscreteSampler):
    """Proxy of C++ IMP::domino::DominoSampler class"""
    __swig_setmethods__ = {}
    for _s in [DiscreteSampler]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DominoSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [DiscreteSampler]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DominoSampler, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::DominoSampler self, Model m, std::string name="DominoSampler %1%") -> DominoSampler
        __init__(IMP::domino::DominoSampler self, Model m) -> DominoSampler
        __init__(IMP::domino::DominoSampler self, Model m, ParticleStatesTable pst, std::string name="DominoSampler %1%") -> DominoSampler
        __init__(IMP::domino::DominoSampler self, Model m, ParticleStatesTable pst) -> DominoSampler
        """
        this = _IMP_domino.new_DominoSampler(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_sample_assignments(self, *args):
        """do_get_sample_assignments(DominoSampler self, Subset known) -> IMP::domino::Assignments"""
        return _IMP_domino.DominoSampler_do_get_sample_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(DominoSampler self) -> VersionInfo"""
        return _IMP_domino.DominoSampler_get_version_info(self)

    def set_merge_tree(self, *args):
        """set_merge_tree(DominoSampler self, IMP::domino::MergeTree const & mt)"""
        return _IMP_domino.DominoSampler_set_merge_tree(self, *args)

    def set_use_cross_subset_filtering(self, *args):
        """set_use_cross_subset_filtering(DominoSampler self, bool tf)"""
        return _IMP_domino.DominoSampler_set_use_cross_subset_filtering(self, *args)

    def get_number_of_assignments_for_vertex(self, *args):
        """get_number_of_assignments_for_vertex(DominoSampler self, unsigned int tree_vertex) -> unsigned int"""
        return _IMP_domino.DominoSampler_get_number_of_assignments_for_vertex(self, *args)

    def get_sample_assignments_for_vertex(self, *args):
        """get_sample_assignments_for_vertex(DominoSampler self, unsigned int tree_vertex) -> IMP::domino::Assignments"""
        return _IMP_domino.DominoSampler_get_sample_assignments_for_vertex(self, *args)

    def get_vertex_assignments(self, *args):
        """
        get_vertex_assignments(DominoSampler self, unsigned int node_index, unsigned int max_states=std::numeric_limits< int >::max()) -> IMP::domino::Assignments
        get_vertex_assignments(DominoSampler self, unsigned int node_index) -> IMP::domino::Assignments
        get_vertex_assignments(DominoSampler self, unsigned int node_index, IMP::domino::Assignments const & first, IMP::domino::Assignments const & second, 
            unsigned int max_states=std::numeric_limits< int >::max()) -> IMP::domino::Assignments
        get_vertex_assignments(DominoSampler self, unsigned int node_index, IMP::domino::Assignments const & first, IMP::domino::Assignments const & second) -> IMP::domino::Assignments
        """
        return _IMP_domino.DominoSampler_get_vertex_assignments(self, *args)

    def load_vertex_assignments(self, *args):
        """
        load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer ac, unsigned int max_states=std::numeric_limits< int >::max())
        load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer ac)
        load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer first, AssignmentContainer second, AssignmentContainer ac, 
            unsigned int max_states=std::numeric_limits< int >::max())
        load_vertex_assignments(DominoSampler self, unsigned int node_index, AssignmentContainer first, AssignmentContainer second, AssignmentContainer ac)
        """
        return _IMP_domino.DominoSampler_load_vertex_assignments(self, *args)

    def __str__(self):
        """__str__(DominoSampler self) -> std::string"""
        return _IMP_domino.DominoSampler___str__(self)

    def __repr__(self):
        """__repr__(DominoSampler self) -> std::string"""
        return _IMP_domino.DominoSampler___repr__(self)

    def get_from(o):
       return _object_cast_to_DominoSampler(o)
    get_from = staticmethod(get_from)

DominoSampler_swigregister = _IMP_domino.DominoSampler_swigregister
DominoSampler_swigregister(DominoSampler)

class BranchAndBoundSampler(DiscreteSampler):
    """Proxy of C++ IMP::domino::BranchAndBoundSampler class"""
    __swig_setmethods__ = {}
    for _s in [DiscreteSampler]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BranchAndBoundSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [DiscreteSampler]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BranchAndBoundSampler, name)
    def __init__(self, *args): 
        """
        __init__(IMP::domino::BranchAndBoundSampler self, Model m, std::string name="BranchAndBoundSampler %1%") -> BranchAndBoundSampler
        __init__(IMP::domino::BranchAndBoundSampler self, Model m) -> BranchAndBoundSampler
        __init__(IMP::domino::BranchAndBoundSampler self, Model m, ParticleStatesTable pst, std::string name="BranchAndBoundSampler %1%") -> BranchAndBoundSampler
        __init__(IMP::domino::BranchAndBoundSampler self, Model m, ParticleStatesTable pst) -> BranchAndBoundSampler
        """
        this = _IMP_domino.new_BranchAndBoundSampler(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_sample_assignments(self, *args):
        """do_get_sample_assignments(BranchAndBoundSampler self, Subset known) -> IMP::domino::Assignments"""
        return _IMP_domino.BranchAndBoundSampler_do_get_sample_assignments(self, *args)

    def get_version_info(self):
        """get_version_info(BranchAndBoundSampler self) -> VersionInfo"""
        return _IMP_domino.BranchAndBoundSampler_get_version_info(self)

    def __str__(self):
        """__str__(BranchAndBoundSampler self) -> std::string"""
        return _IMP_domino.BranchAndBoundSampler___str__(self)

    def __repr__(self):
        """__repr__(BranchAndBoundSampler self) -> std::string"""
        return _IMP_domino.BranchAndBoundSampler___repr__(self)

    def get_from(o):
       return _object_cast_to_BranchAndBoundSampler(o)
    get_from = staticmethod(get_from)

BranchAndBoundSampler_swigregister = _IMP_domino.BranchAndBoundSampler_swigregister
BranchAndBoundSampler_swigregister(BranchAndBoundSampler)


def load_particle_states(*args):
  """load_particle_states(Subset s, Assignment ss, ParticleStatesTable pst)"""
  return _IMP_domino.load_particle_states(*args)

def get_restraints(*args):
  """get_restraints(Subset s, ParticleStatesTable pst, IMP::kernel::DependencyGraph const & dg, RestraintSet rs) -> IMP::kernel::RestraintsTemp"""
  return _IMP_domino.get_restraints(*args)

def get_index(*args):
  """get_index(IMP::kernel::ParticlesTemp const & particles, Subset subset, IMP::domino::Subsets const & excluded) -> IMP::Ints"""
  return _IMP_domino.get_index(*args)

def get_partial_index(*args):
  """get_partial_index(IMP::kernel::ParticlesTemp const & particles, Subset subset, IMP::domino::Subsets const & excluded) -> IMP::Ints"""
  return _IMP_domino.get_partial_index(*args)

def get_possible_interactions(*args):
  """get_possible_interactions(IMP::kernel::ParticlesTemp const & ps, double max_distance, ParticleStatesTable pst) -> IMP::kernel::ParticlePairsTemp"""
  return _IMP_domino.get_possible_interactions(*args)

def get_embedding(*args):
  """get_embedding(Subset s, Assignment a, ParticleStatesTable pst) -> VectorKD"""
  return _IMP_domino.get_embedding(*args)

def get_nearest_assignment(*args):
  """get_nearest_assignment(Subset s, VectorKD embedding, ParticleStatesTable pst) -> Assignment"""
  return _IMP_domino.get_nearest_assignment(*args)

def get_distance_if_smaller_than(*args):
  """
    get_distance_if_smaller_than(Subset s, Assignment a, Assignment b, ParticleStatesTable pst, IMP::statistics::Metrics const & metrics, 
        double max) -> double
    """
  return _IMP_domino.get_distance_if_smaller_than(*args)

def load_leaf_assignments(*args):
  """load_leaf_assignments(Subset subset, AssignmentsTable at, AssignmentContainer ac)"""
  return _IMP_domino.load_leaf_assignments(*args)

def load_merged_assignments(*args):
  """
    load_merged_assignments(Subset first_subset, AssignmentContainer first, Subset second_subset, AssignmentContainer second, 
        IMP::domino::SubsetFilterTablesTemp const & filters, AssignmentContainer ret)
    """
  return _IMP_domino.load_merged_assignments(*args)

def load_merged_assignments_random_order(*args):
  """
    load_merged_assignments_random_order(Subset first_subset, AssignmentContainer first, Subset second_subset, AssignmentContainer second, 
        IMP::domino::SubsetFilterTablesTemp const & filters, unsigned int maximum_tries, 
        AssignmentContainer ret)
    """
  return _IMP_domino.load_merged_assignments_random_order(*args)

def get_state_clusters(*args):
  """
    get_state_clusters(Subset subset, IMP::domino::Assignments const & states, ParticleStatesTable pst, 
        double resolution) -> IMP::domino::Assignments
    """
  return _IMP_domino.get_state_clusters(*args)
class DependencyScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::domino::DependencyScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DependencyScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DependencyScoreState, name)
    def __init__(self, *args): 
        """__init__(IMP::domino::DependencyScoreState self, Model m) -> DependencyScoreState"""
        this = _IMP_domino.new_DependencyScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_input_particles(self, *args):
        """set_input_particles(DependencyScoreState self, IMP::kernel::ParticlesTemp const & pt)"""
        return _IMP_domino.DependencyScoreState_set_input_particles(self, *args)

    def set_output_particles(self, *args):
        """set_output_particles(DependencyScoreState self, IMP::kernel::ParticlesTemp const & pt)"""
        return _IMP_domino.DependencyScoreState_set_output_particles(self, *args)

    def set_input_containers(self, *args):
        """set_input_containers(DependencyScoreState self, IMP::kernel::ContainersTemp const & pt)"""
        return _IMP_domino.DependencyScoreState_set_input_containers(self, *args)

    def set_output_containers(self, *args):
        """set_output_containers(DependencyScoreState self, IMP::kernel::ContainersTemp const & pt)"""
        return _IMP_domino.DependencyScoreState_set_output_containers(self, *args)

    def get_version_info(self):
        """get_version_info(DependencyScoreState self) -> VersionInfo"""
        return _IMP_domino.DependencyScoreState_get_version_info(self)

    def __str__(self):
        """__str__(DependencyScoreState self) -> std::string"""
        return _IMP_domino.DependencyScoreState___str__(self)

    def __repr__(self):
        """__repr__(DependencyScoreState self) -> std::string"""
        return _IMP_domino.DependencyScoreState___repr__(self)

    def get_from(o):
       return _object_cast_to_DependencyScoreState(o)
    get_from = staticmethod(get_from)

DependencyScoreState_swigregister = _IMP_domino.DependencyScoreState_swigregister
DependencyScoreState_swigregister(DependencyScoreState)


def _get_ints_list(*args):
  """_get_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
  return _IMP_domino._get_ints_list(*args)

def get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_domino.get_module_version()

def get_example_path(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_domino.get_example_path(*args)

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_domino.get_data_path(*args)
import _version_check
_version_check.check_version(get_module_version())

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