domino/__init__.py

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


# This wrapper is part of IMP,
# Copyright 2007-2024 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import



from sys import version_info as _swig_python_version_info
import _IMP_domino

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


import weakref

class IMP_DOMINO_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_DOMINO_SwigPyIterator class."""

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

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

    def value(self):
        r"""value(IMP_DOMINO_SwigPyIterator self) -> PyObject *"""
        return _IMP_domino.IMP_DOMINO_SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register IMP_DOMINO_SwigPyIterator in _IMP_domino:
_IMP_domino.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_KERNEL_HAS_LOG4CXX = _IMP_domino.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_domino.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_domino.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_domino.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_domino.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_domino.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_domino.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_domino.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_domino.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_domino.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_domino.IMPKERNEL_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]
# Do in two steps so the references are kept until the end of the
# function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    r"""Proxy of C++ std::ostream class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        r"""write(_ostream self, char const * osa_buf)"""
        return _IMP_domino._ostream_write(self, osa_buf)

# Register _ostream in _IMP_domino:
_IMP_domino._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_domino.IMP_C_OPEN_BINARY

import IMP
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

IMP_CGAL_HAS_NUMPY = _IMP_domino.IMP_CGAL_HAS_NUMPY

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_NUMPY = _IMP_domino.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_domino.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_domino.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
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

IMP_DISPLAY_HAS_NUMPY = _IMP_domino.IMP_DISPLAY_HAS_NUMPY

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

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_domino.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_domino.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
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

IMP_STATISTICS_HAS_NUMPY = _IMP_domino.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_domino.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
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

IMP_CORE_HAS_NUMPY = _IMP_domino.IMP_CORE_HAS_NUMPY

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_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

IMP_CONTAINER_HAS_NUMPY = _IMP_domino.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_domino.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_domino.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_domino.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_domino.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
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

IMP_ATOM_HAS_NUMPY = _IMP_domino.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_domino.IMP_ATOM_HAS_PYTHON_IHM

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

IMP_CHAIN_TYPE_INDEX = _IMP_domino.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_domino.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_domino.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_domino.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_domino.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_domino.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_BOOST_SYSTEM = _IMP_domino.IMP_EM_HAS_BOOST_SYSTEM

IMP_EM_HAS_CGAL = _IMP_domino.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_domino.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_domino.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_domino.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_domino.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_SAXS_HAS_IMP_CGAL = _IMP_domino.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_domino.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_domino.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_domino.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_domino.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_domino.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_domino.IMP_SAXS_HAS_BOOST_SYSTEM

IMP_SAXS_HAS_CGAL = _IMP_domino.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_domino.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_domino.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_domino.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_domino.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_ISD_HAS_IMP_CGAL = _IMP_domino.IMP_ISD_HAS_IMP_CGAL

IMP_ISD_HAS_IMP_DISPLAY = _IMP_domino.IMP_ISD_HAS_IMP_DISPLAY

IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_ISD_HAS_IMP_SCORE_FUNCTOR

IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_domino.IMP_ISD_HAS_BOOST_FILESYSTEM

IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_domino.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS

IMP_ISD_HAS_BOOST_RANDOM = _IMP_domino.IMP_ISD_HAS_BOOST_RANDOM

IMP_ISD_HAS_BOOST_REGEX = _IMP_domino.IMP_ISD_HAS_BOOST_REGEX

IMP_ISD_HAS_BOOST_SYSTEM = _IMP_domino.IMP_ISD_HAS_BOOST_SYSTEM

IMP_ISD_HAS_CGAL = _IMP_domino.IMP_ISD_HAS_CGAL

IMP_ISD_HAS_HDF5 = _IMP_domino.IMP_ISD_HAS_HDF5

IMP_ISD_HAS_NUMPY = _IMP_domino.IMP_ISD_HAS_NUMPY

IMP_ISD_HAS_PYTHON_IHM = _IMP_domino.IMP_ISD_HAS_PYTHON_IHM

IMPISD_SHOW_WARNINGS = _IMP_domino.IMPISD_SHOW_WARNINGS

import IMP.isd
IMP_RMF_HAS_IMP_CGAL = _IMP_domino.IMP_RMF_HAS_IMP_CGAL

IMP_RMF_HAS_IMP_EM = _IMP_domino.IMP_RMF_HAS_IMP_EM

IMP_RMF_HAS_IMP_SAXS = _IMP_domino.IMP_RMF_HAS_IMP_SAXS

IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_domino.IMP_RMF_HAS_IMP_SCORE_FUNCTOR

IMP_RMF_HAS_IMP_STATISTICS = _IMP_domino.IMP_RMF_HAS_IMP_STATISTICS

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

IMP_RMF_HAS_NUMPY = _IMP_domino.IMP_RMF_HAS_NUMPY

IMP_RMF_HAS_PYTHON_IHM = _IMP_domino.IMP_RMF_HAS_PYTHON_IHM

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_CGAL = _IMP_domino.IMP_DOMINO_HAS_IMP_CGAL

IMP_DOMINO_HAS_IMP_EM = _IMP_domino.IMP_DOMINO_HAS_IMP_EM

IMP_DOMINO_HAS_IMP_ISD = _IMP_domino.IMP_DOMINO_HAS_IMP_ISD

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_SAXS = _IMP_domino.IMP_DOMINO_HAS_IMP_SAXS

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_NUMPY = _IMP_domino.IMP_DOMINO_HAS_NUMPY

IMP_DOMINO_HAS_RMF = _IMP_domino.IMP_DOMINO_HAS_RMF

IMP_DOMINO_HAS_PYTHON_IHM = _IMP_domino.IMP_DOMINO_HAS_PYTHON_IHM

IMPDOMINO_SHOW_WARNINGS = _IMP_domino.IMPDOMINO_SHOW_WARNINGS

import RMF_HDF5

_object_types.append("DiscreteSampler")


def _object_cast_to_DiscreteSampler(o):
    r"""_object_cast_to_DiscreteSampler(Object o) -> DiscreteSampler"""
    return _IMP_domino._object_cast_to_DiscreteSampler(o)

_object_types.append("ParticleStates")


def _object_cast_to_ParticleStates(o):
    r"""_object_cast_to_ParticleStates(Object o) -> ParticleStates"""
    return _IMP_domino._object_cast_to_ParticleStates(o)

_object_types.append("SubsetFilter")


def _object_cast_to_SubsetFilter(o):
    r"""_object_cast_to_SubsetFilter(Object o) -> SubsetFilter"""
    return _IMP_domino._object_cast_to_SubsetFilter(o)

_object_types.append("SubsetFilterTable")


def _object_cast_to_SubsetFilterTable(o):
    r"""_object_cast_to_SubsetFilterTable(Object o) -> SubsetFilterTable"""
    return _IMP_domino._object_cast_to_SubsetFilterTable(o)

_object_types.append("AssignmentsTable")


def _object_cast_to_AssignmentsTable(o):
    r"""_object_cast_to_AssignmentsTable(Object o) -> AssignmentsTable"""
    return _IMP_domino._object_cast_to_AssignmentsTable(o)

_object_types.append("AssignmentContainer")


def _object_cast_to_AssignmentContainer(o):
    r"""_object_cast_to_AssignmentContainer(Object o) -> AssignmentContainer"""
    return _IMP_domino._object_cast_to_AssignmentContainer(o)
class InteractionGraph(IMP.Object):
    r"""Proxy of C++ IMP::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::Particle *,IMP::domino::ShowInteractionGraphVertex > class."""

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

    def __init__(self):
        r"""__init__(InteractionGraph self) -> InteractionGraph"""
        _IMP_domino.InteractionGraph_swiginit(self, _IMP_domino.new_InteractionGraph())

    def get_graph(self):
        r"""get_graph(InteractionGraph self) -> IMP::domino::InteractionGraph const &"""
        return _IMP_domino.InteractionGraph_get_graph(self)

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

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

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

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

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

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

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

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

    def remove_vertex(self, l):
        r"""remove_vertex(InteractionGraph self, IMP::internal::BoostDigraph< IMP::domino::InteractionGraph,IMP::Particle *,IMP::domino::ShowInteractionGraphVertex >::VertexDescriptor l)"""
        return _IMP_domino.InteractionGraph_remove_vertex(self, l)
    __swig_destroy__ = _IMP_domino.delete_InteractionGraph

# Register InteractionGraph in _IMP_domino:
_IMP_domino.InteractionGraph_swigregister(InteractionGraph)

_value_types.append("InteractionGraph")

class SubsetGraph(IMP.Object):
    r"""Proxy of C++ IMP::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex > class."""

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

    def __init__(self):
        r"""__init__(SubsetGraph self) -> SubsetGraph"""
        _IMP_domino.SubsetGraph_swiginit(self, _IMP_domino.new_SubsetGraph())

    def get_graph(self):
        r"""get_graph(SubsetGraph self) -> IMP::domino::SubsetGraph const &"""
        return _IMP_domino.SubsetGraph_get_graph(self)

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

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

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

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

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

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

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

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

    def remove_vertex(self, l):
        r"""remove_vertex(SubsetGraph self, IMP::internal::BoostDigraph< IMP::domino::SubsetGraph,IMP::domino::Subset,IMP::domino::ShowSubsetGraphVertex >::VertexDescriptor l)"""
        return _IMP_domino.SubsetGraph_remove_vertex(self, l)
    __swig_destroy__ = _IMP_domino.delete_SubsetGraph

# Register SubsetGraph in _IMP_domino:
_IMP_domino.SubsetGraph_swigregister(SubsetGraph)

_value_types.append("SubsetGraph")

class CliqueGraph(IMP.Object):
    r"""Proxy of C++ IMP::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex > class."""

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

    def __init__(self):
        r"""__init__(CliqueGraph self) -> CliqueGraph"""
        _IMP_domino.CliqueGraph_swiginit(self, _IMP_domino.new_CliqueGraph())

    def get_graph(self):
        r"""get_graph(CliqueGraph self) -> IMP::domino::CliqueGraph const &"""
        return _IMP_domino.CliqueGraph_get_graph(self)

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

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

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

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

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

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

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

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

    def remove_vertex(self, l):
        r"""remove_vertex(CliqueGraph self, IMP::internal::BoostDigraph< IMP::domino::CliqueGraph,IMP::domino::Subset,IMP::domino::ShowCliqueGraphVertex >::VertexDescriptor l)"""
        return _IMP_domino.CliqueGraph_remove_vertex(self, l)
    __swig_destroy__ = _IMP_domino.delete_CliqueGraph

# Register CliqueGraph in _IMP_domino:
_IMP_domino.CliqueGraph_swigregister(CliqueGraph)

_value_types.append("CliqueGraph")

class MergeTree(IMP.Object):
    r"""Proxy of C++ IMP::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex > class."""

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

    def __init__(self):
        r"""__init__(MergeTree self) -> MergeTree"""
        _IMP_domino.MergeTree_swiginit(self, _IMP_domino.new_MergeTree())

    def get_graph(self):
        r"""get_graph(MergeTree self) -> IMP::domino::MergeTree const &"""
        return _IMP_domino.MergeTree_get_graph(self)

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

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

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

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

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

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

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

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

    def remove_vertex(self, l):
        r"""remove_vertex(MergeTree self, IMP::internal::BoostDigraph< IMP::domino::MergeTree,IMP::domino::Subset,IMP::domino::ShowMergeTreeVertex >::VertexDescriptor l)"""
        return _IMP_domino.MergeTree_remove_vertex(self, l)
    __swig_destroy__ = _IMP_domino.delete_MergeTree

# Register MergeTree in _IMP_domino:
_IMP_domino.MergeTree_swigregister(MergeTree)

_value_types.append("MergeTree")


_object_types.append("BranchAndBoundSampler")


def _object_cast_to_BranchAndBoundSampler(o):
    r"""_object_cast_to_BranchAndBoundSampler(Object o) -> BranchAndBoundSampler"""
    return _IMP_domino._object_cast_to_BranchAndBoundSampler(o)

_object_types.append("BranchAndBoundAssignmentsTable")


def _object_cast_to_BranchAndBoundAssignmentsTable(o):
    r"""_object_cast_to_BranchAndBoundAssignmentsTable(Object o) -> BranchAndBoundAssignmentsTable"""
    return _IMP_domino._object_cast_to_BranchAndBoundAssignmentsTable(o)

_object_types.append("RecursiveAssignmentsTable")


def _object_cast_to_RecursiveAssignmentsTable(o):
    r"""_object_cast_to_RecursiveAssignmentsTable(Object o) -> RecursiveAssignmentsTable"""
    return _IMP_domino._object_cast_to_RecursiveAssignmentsTable(o)

_object_types.append("SimpleAssignmentsTable")


def _object_cast_to_SimpleAssignmentsTable(o):
    r"""_object_cast_to_SimpleAssignmentsTable(Object o) -> SimpleAssignmentsTable"""
    return _IMP_domino._object_cast_to_SimpleAssignmentsTable(o)

_object_types.append("CompoundStates")


def _object_cast_to_CompoundStates(o):
    r"""_object_cast_to_CompoundStates(Object o) -> CompoundStates"""
    return _IMP_domino._object_cast_to_CompoundStates(o)

_object_types.append("DisjointSetsSubsetFilterTable")


def _object_cast_to_DisjointSetsSubsetFilterTable(o):
    r"""_object_cast_to_DisjointSetsSubsetFilterTable(Object o) -> DisjointSetsSubsetFilterTable"""
    return _IMP_domino._object_cast_to_DisjointSetsSubsetFilterTable(o)

_object_types.append("MinimumRestraintScoreSubsetFilterTable")


def _object_cast_to_MinimumRestraintScoreSubsetFilterTable(o):
    r"""_object_cast_to_MinimumRestraintScoreSubsetFilterTable(Object o) -> MinimumRestraintScoreSubsetFilterTable"""
    return _IMP_domino._object_cast_to_MinimumRestraintScoreSubsetFilterTable(o)

_object_types.append("DominoSampler")


def _object_cast_to_DominoSampler(o):
    r"""_object_cast_to_DominoSampler(Object o) -> DominoSampler"""
    return _IMP_domino._object_cast_to_DominoSampler(o)

_object_types.append("EqualitySubsetFilterTable")


def _object_cast_to_EqualitySubsetFilterTable(o):
    r"""_object_cast_to_EqualitySubsetFilterTable(Object o) -> EqualitySubsetFilterTable"""
    return _IMP_domino._object_cast_to_EqualitySubsetFilterTable(o)

_object_types.append("EquivalenceSubsetFilterTable")


def _object_cast_to_EquivalenceSubsetFilterTable(o):
    r"""_object_cast_to_EquivalenceSubsetFilterTable(Object o) -> EquivalenceSubsetFilterTable"""
    return _IMP_domino._object_cast_to_EquivalenceSubsetFilterTable(o)

_object_types.append("EquivalenceAndExclusionSubsetFilterTable")


def _object_cast_to_EquivalenceAndExclusionSubsetFilterTable(o):
    r"""_object_cast_to_EquivalenceAndExclusionSubsetFilterTable(Object o) -> EquivalenceAndExclusionSubsetFilterTable"""
    return _IMP_domino._object_cast_to_EquivalenceAndExclusionSubsetFilterTable(o)

_object_types.append("ExclusionSubsetFilterTable")


def _object_cast_to_ExclusionSubsetFilterTable(o):
    r"""_object_cast_to_ExclusionSubsetFilterTable(Object o) -> ExclusionSubsetFilterTable"""
    return _IMP_domino._object_cast_to_ExclusionSubsetFilterTable(o)

_object_types.append("IndexStates")


def _object_cast_to_IndexStates(o):
    r"""_object_cast_to_IndexStates(Object o) -> IndexStates"""
    return _IMP_domino._object_cast_to_IndexStates(o)

_object_types.append("ListSubsetFilterTable")


def _object_cast_to_ListSubsetFilterTable(o):
    r"""_object_cast_to_ListSubsetFilterTable(Object o) -> ListSubsetFilterTable"""
    return _IMP_domino._object_cast_to_ListSubsetFilterTable(o)

_object_types.append("ListAssignmentsTable")


def _object_cast_to_ListAssignmentsTable(o):
    r"""_object_cast_to_ListAssignmentsTable(Object o) -> ListAssignmentsTable"""
    return _IMP_domino._object_cast_to_ListAssignmentsTable(o)

_object_types.append("ParticleStatesTable")


def _object_cast_to_ParticleStatesTable(o):
    r"""_object_cast_to_ParticleStatesTable(Object o) -> ParticleStatesTable"""
    return _IMP_domino._object_cast_to_ParticleStatesTable(o)

_object_types.append("RecursiveStates")


def _object_cast_to_RecursiveStates(o):
    r"""_object_cast_to_RecursiveStates(Object o) -> RecursiveStates"""
    return _IMP_domino._object_cast_to_RecursiveStates(o)

_object_types.append("ProbabilisticSubsetFilterTable")


def _object_cast_to_ProbabilisticSubsetFilterTable(o):
    r"""_object_cast_to_ProbabilisticSubsetFilterTable(Object o) -> ProbabilisticSubsetFilterTable"""
    return _IMP_domino._object_cast_to_ProbabilisticSubsetFilterTable(o)

_object_types.append("RestraintScoreSubsetFilterTable")


def _object_cast_to_RestraintScoreSubsetFilterTable(o):
    r"""_object_cast_to_RestraintScoreSubsetFilterTable(Object o) -> RestraintScoreSubsetFilterTable"""
    return _IMP_domino._object_cast_to_RestraintScoreSubsetFilterTable(o)

_object_types.append("RigidBodyStates")


def _object_cast_to_RigidBodyStates(o):
    r"""_object_cast_to_RigidBodyStates(Object o) -> RigidBodyStates"""
    return _IMP_domino._object_cast_to_RigidBodyStates(o)

_object_types.append("XYZStates")


def _object_cast_to_XYZStates(o):
    r"""_object_cast_to_XYZStates(Object o) -> XYZStates"""
    return _IMP_domino._object_cast_to_XYZStates(o)

_object_types.append("NestedRigidBodyStates")


def _object_cast_to_NestedRigidBodyStates(o):
    r"""_object_cast_to_NestedRigidBodyStates(Object o) -> NestedRigidBodyStates"""
    return _IMP_domino._object_cast_to_NestedRigidBodyStates(o)

_object_types.append("DependencyScoreState")


def _object_cast_to_DependencyScoreState(o):
    r"""_object_cast_to_DependencyScoreState(Object o) -> DependencyScoreState"""
    return _IMP_domino._object_cast_to_DependencyScoreState(o)

_object_types.append("PairListSubsetFilterTable")


def _object_cast_to_PairListSubsetFilterTable(o):
    r"""_object_cast_to_PairListSubsetFilterTable(Object o) -> PairListSubsetFilterTable"""
    return _IMP_domino._object_cast_to_PairListSubsetFilterTable(o)

_object_types.append("ListAssignmentContainer")


def _object_cast_to_ListAssignmentContainer(o):
    r"""_object_cast_to_ListAssignmentContainer(Object o) -> ListAssignmentContainer"""
    return _IMP_domino._object_cast_to_ListAssignmentContainer(o)

_object_types.append("PackedAssignmentContainer")


def _object_cast_to_PackedAssignmentContainer(o):
    r"""_object_cast_to_PackedAssignmentContainer(Object o) -> PackedAssignmentContainer"""
    return _IMP_domino._object_cast_to_PackedAssignmentContainer(o)

_object_types.append("HeapAssignmentContainer")


def _object_cast_to_HeapAssignmentContainer(o):
    r"""_object_cast_to_HeapAssignmentContainer(Object o) -> HeapAssignmentContainer"""
    return _IMP_domino._object_cast_to_HeapAssignmentContainer(o)

_object_types.append("RangeViewAssignmentContainer")


def _object_cast_to_RangeViewAssignmentContainer(o):
    r"""_object_cast_to_RangeViewAssignmentContainer(Object o) -> RangeViewAssignmentContainer"""
    return _IMP_domino._object_cast_to_RangeViewAssignmentContainer(o)

_object_types.append("SampleAssignmentContainer")


def _object_cast_to_SampleAssignmentContainer(o):
    r"""_object_cast_to_SampleAssignmentContainer(Object o) -> SampleAssignmentContainer"""
    return _IMP_domino._object_cast_to_SampleAssignmentContainer(o)

_object_types.append("PermutationStates")


def _object_cast_to_PermutationStates(o):
    r"""_object_cast_to_PermutationStates(Object o) -> PermutationStates"""
    return _IMP_domino._object_cast_to_PermutationStates(o)

_object_types.append("WriteHDF5AssignmentContainer")


def _object_cast_to_WriteHDF5AssignmentContainer(o):
    r"""_object_cast_to_WriteHDF5AssignmentContainer(Object o) -> WriteHDF5AssignmentContainer"""
    return _IMP_domino._object_cast_to_WriteHDF5AssignmentContainer(o)

_object_types.append("ReadHDF5AssignmentContainer")


def _object_cast_to_ReadHDF5AssignmentContainer(o):
    r"""_object_cast_to_ReadHDF5AssignmentContainer(Object o) -> ReadHDF5AssignmentContainer"""
    return _IMP_domino._object_cast_to_ReadHDF5AssignmentContainer(o)

_object_types.append("ReadAssignmentContainer")


def _object_cast_to_ReadAssignmentContainer(o):
    r"""_object_cast_to_ReadAssignmentContainer(Object o) -> ReadAssignmentContainer"""
    return _IMP_domino._object_cast_to_ReadAssignmentContainer(o)

_object_types.append("WriteAssignmentContainer")


def _object_cast_to_WriteAssignmentContainer(o):
    r"""_object_cast_to_WriteAssignmentContainer(Object o) -> WriteAssignmentContainer"""
    return _IMP_domino._object_cast_to_WriteAssignmentContainer(o)

_object_types.append("CappedAssignmentContainer")


def _object_cast_to_CappedAssignmentContainer(o):
    r"""_object_cast_to_CappedAssignmentContainer(Object o) -> CappedAssignmentContainer"""
    return _IMP_domino._object_cast_to_CappedAssignmentContainer(o)

_object_types.append("RestraintCache")


def _object_cast_to_RestraintCache(o):
    r"""_object_cast_to_RestraintCache(Object o) -> RestraintCache"""
    return _IMP_domino._object_cast_to_RestraintCache(o)

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._Value):
    r"""Proxy of C++ IMP::ConstVector< int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete__IntArray

    def __init__(self, *args):
        r"""
        __init__(_IntArray self, unsigned int sz, int fill) -> _IntArray
        __init__(_IntArray self) -> _IntArray
        """
        _IMP_domino._IntArray_swiginit(self, _IMP_domino.new__IntArray(*args))

    def __cmp__(self, o):
        r"""__cmp__(_IntArray self, _IntArray o) -> int"""
        return _IMP_domino._IntArray___cmp__(self, o)

    def __eq__(self, o):
        r"""__eq__(_IntArray self, _IntArray o) -> bool"""
        return _IMP_domino._IntArray___eq__(self, o)

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

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

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

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

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

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

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

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

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

# Register _IntArray in _IMP_domino:
_IMP_domino._IntArray_swigregister(_IntArray)
class _UIntArray(IMP._Value):
    r"""Proxy of C++ IMP::ConstVector< unsigned int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete__UIntArray

    def __init__(self, *args):
        r"""
        __init__(_UIntArray self, unsigned int sz, unsigned int fill) -> _UIntArray
        __init__(_UIntArray self) -> _UIntArray
        """
        _IMP_domino._UIntArray_swiginit(self, _IMP_domino.new__UIntArray(*args))

    def __cmp__(self, o):
        r"""__cmp__(_UIntArray self, _UIntArray o) -> int"""
        return _IMP_domino._UIntArray___cmp__(self, o)

    def __eq__(self, o):
        r"""__eq__(_UIntArray self, _UIntArray o) -> bool"""
        return _IMP_domino._UIntArray___eq__(self, o)

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

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

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

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

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

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

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

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

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

# Register _UIntArray in _IMP_domino:
_IMP_domino._UIntArray_swigregister(_UIntArray)
class _ParticleArray(IMP._Value):
    r"""Proxy of C++ IMP::ConstVector< IMP::WeakPointer< Particle >,Particle * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_domino.delete__ParticleArray

    def __init__(self, *args):
        r"""
        __init__(_ParticleArray self, unsigned int sz, IMP::WeakPointer< IMP::Particle > fill) -> _ParticleArray
        __init__(_ParticleArray self) -> _ParticleArray
        """
        _IMP_domino._ParticleArray_swiginit(self, _IMP_domino.new__ParticleArray(*args))

    def __cmp__(self, o):
        r"""__cmp__(_ParticleArray self, _ParticleArray o) -> int"""
        return _IMP_domino._ParticleArray___cmp__(self, o)

    def __eq__(self, o):
        r"""__eq__(_ParticleArray self, _ParticleArray o) -> bool"""
        return _IMP_domino._ParticleArray___eq__(self, o)

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

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

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

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

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

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

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

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

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

# Register _ParticleArray in _IMP_domino:
_IMP_domino._ParticleArray_swigregister(_ParticleArray)
class Subset(_ParticleArray):
    r"""Proxy of C++ IMP::domino::Subset class."""

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

    def __init__(self, *args):
        r"""
        __init__(Subset self, IMP::ParticlesTemp const & ps, bool arg3) -> Subset
        __init__(Subset self) -> Subset
        __init__(Subset self, IMP::ParticlesTemp ps) -> Subset
        """
        _IMP_domino.Subset_swiginit(self, _IMP_domino.new_Subset(*args))

    def get_model(self):
        r"""get_model(Subset self) -> Model"""
        return _IMP_domino.Subset_get_model(self)

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

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

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

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

# Register Subset in _IMP_domino:
_IMP_domino.Subset_swigregister(Subset)

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

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

def get_difference(a, b):
    r"""get_difference(Subset a, Subset b) -> Subset"""
    return _IMP_domino.get_difference(a, b)
class Assignment(_IntArray):
    r"""Proxy of C++ IMP::domino::Assignment class."""

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

    def __init__(self, *args):
        r"""
        __init__(Assignment self) -> Assignment
        __init__(Assignment self, unsigned int sz) -> Assignment
        __init__(Assignment self, IMP::Ints const & i) -> Assignment
        """
        _IMP_domino.Assignment_swiginit(self, _IMP_domino.new_Assignment(*args))

    def __str__(self):
        r"""__str__(Assignment self) -> std::string"""
        return _IMP_domino.Assignment___str__(self)

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

    def _get_as_binary(self):
        r"""_get_as_binary(Assignment self) -> PyObject *"""
        return _IMP_domino.Assignment__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Assignment self, PyObject * p)"""
        return _IMP_domino.Assignment__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_domino.delete_Assignment

# Register Assignment in _IMP_domino:
_IMP_domino.Assignment_swigregister(Assignment)
class Slice(_UIntArray):
    r"""Proxy of C++ IMP::domino::Slice class."""

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

    def __init__(self, *args):
        r"""
        __init__(Slice self) -> Slice
        __init__(Slice self, Subset outer, Subset inner) -> Slice
        """
        _IMP_domino.Slice_swiginit(self, _IMP_domino.new_Slice(*args))

    def get_sliced(self, *args):
        r"""
        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):
        r"""__str__(Slice self) -> std::string"""
        return _IMP_domino.Slice___str__(self)

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

    def _get_as_binary(self):
        r"""_get_as_binary(Slice self) -> PyObject *"""
        return _IMP_domino.Slice__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Slice self, PyObject * p)"""
        return _IMP_domino.Slice__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_domino.delete_Slice

# Register Slice in _IMP_domino:
_IMP_domino.Slice_swigregister(Slice)

def get_slice(outer, inner, excluded):
    r"""get_slice(Subset outer, Subset inner, IMP::domino::Subsets const & excluded) -> Slice"""
    return _IMP_domino.get_slice(outer, inner, excluded)
class Order(_UIntArray):
    r"""Proxy of C++ IMP::domino::Order class."""

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

    def __init__(self, *args):
        r"""
        __init__(Order self) -> Order
        __init__(Order self, Subset outer, IMP::ParticlesTemp const & order) -> Order
        """
        _IMP_domino.Order_swiginit(self, _IMP_domino.new_Order(*args))

    def get_list_ordered(self, a):
        r"""get_list_ordered(Order self, Assignment a) -> IMP::Ints"""
        return _IMP_domino.Order_get_list_ordered(self, a)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Order self) -> PyObject *"""
        return _IMP_domino.Order__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Order self, PyObject * p)"""
        return _IMP_domino.Order__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_domino.delete_Order

# Register Order in _IMP_domino:
_IMP_domino.Order_swigregister(Order)
class ParticleStates(IMP.Object):
    r"""Proxy of C++ IMP::domino::ParticleStates class."""

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

    def __init__(self, *args):
        r"""__init__(ParticleStates self, std::string name="ParticleStates %1%") -> ParticleStates"""
        if self.__class__ == ParticleStates:
            _self = None
        else:
            _self = self
        _IMP_domino.ParticleStates_swiginit(self, _IMP_domino.new_ParticleStates(_self, *args))

        if self.__class__ != ParticleStates:
            _director_objects.register(self)




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

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

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

    def get_nearest_state(self, v):
        r"""get_nearest_state(ParticleStates self, VectorKD v) -> unsigned int"""
        return _IMP_domino.ParticleStates_get_nearest_state(self, v)
    __swig_destroy__ = _IMP_domino.delete_ParticleStates

    def __str__(self):
        r"""__str__(ParticleStates self) -> std::string"""
        return _IMP_domino.ParticleStates___str__(self)

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

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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_ParticleStates(o)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_ParticleStates(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(ParticleStates self)"""
        return _IMP_domino.ParticleStates_do_destroy(self)

# Register ParticleStates in _IMP_domino:
_IMP_domino.ParticleStates_swigregister(ParticleStates)
class ParticleStatesTable(IMP.Object):
    r"""Proxy of C++ IMP::domino::ParticleStatesTable class."""

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

    def __init__(self):
        r"""__init__(ParticleStatesTable self) -> ParticleStatesTable"""
        _IMP_domino.ParticleStatesTable_swiginit(self, _IMP_domino.new_ParticleStatesTable())

    def get_particle_states(self, p):
        r"""get_particle_states(ParticleStatesTable self, Particle p) -> ParticleStates"""
        return _IMP_domino.ParticleStatesTable_get_particle_states(self, p)

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(ParticleStatesTable self) -> VersionInfo"""
        return _IMP_domino.ParticleStatesTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ParticleStatesTable

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

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

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


# Register ParticleStatesTable in _IMP_domino:
_IMP_domino.ParticleStatesTable_swigregister(ParticleStatesTable)
class IndexStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::IndexStates class."""

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

    def __init__(self, *args):
        r"""__init__(IndexStates self, unsigned int n, IntKey k=IMP::IntKey("state")) -> IndexStates"""
        _IMP_domino.IndexStates_swiginit(self, _IMP_domino.new_IndexStates(*args))

    def get_version_info(self):
        r"""get_version_info(IndexStates self) -> VersionInfo"""
        return _IMP_domino.IndexStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_IndexStates

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

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

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


# Register IndexStates in _IMP_domino:
_IMP_domino.IndexStates_swigregister(IndexStates)
class XYZStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::XYZStates class."""

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

    def __init__(self, states):
        r"""__init__(XYZStates self, IMP::algebra::Vector3Ds const & states) -> XYZStates"""
        _IMP_domino.XYZStates_swiginit(self, _IMP_domino.new_XYZStates(states))

    def get_vector(self, i):
        r"""get_vector(XYZStates self, unsigned int i) -> Vector3D"""
        return _IMP_domino.XYZStates_get_vector(self, i)

    def get_version_info(self):
        r"""get_version_info(XYZStates self) -> VersionInfo"""
        return _IMP_domino.XYZStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_XYZStates

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

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

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


# Register XYZStates in _IMP_domino:
_IMP_domino.XYZStates_swigregister(XYZStates)
class RigidBodyStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::RigidBodyStates class."""

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

    def __init__(self, states, scale=1):
        r"""__init__(RigidBodyStates self, IMP::algebra::ReferenceFrame3Ds const & states, double scale=1) -> RigidBodyStates"""
        _IMP_domino.RigidBodyStates_swiginit(self, _IMP_domino.new_RigidBodyStates(states, scale))

    def get_reference_frame(self, i):
        r"""get_reference_frame(RigidBodyStates self, unsigned int i) -> ReferenceFrame3D"""
        return _IMP_domino.RigidBodyStates_get_reference_frame(self, i)

    def get_version_info(self):
        r"""get_version_info(RigidBodyStates self) -> VersionInfo"""
        return _IMP_domino.RigidBodyStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_RigidBodyStates

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

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

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


# Register RigidBodyStates in _IMP_domino:
_IMP_domino.RigidBodyStates_swigregister(RigidBodyStates)
class NestedRigidBodyStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::NestedRigidBodyStates class."""

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

    def __init__(self, states, scale=100):
        r"""__init__(NestedRigidBodyStates self, IMP::algebra::Transformation3Ds const & states, double scale=100) -> NestedRigidBodyStates"""
        _IMP_domino.NestedRigidBodyStates_swiginit(self, _IMP_domino.new_NestedRigidBodyStates(states, scale))

    def get_transformation(self, i):
        r"""get_transformation(NestedRigidBodyStates self, unsigned int i) -> Transformation3D"""
        return _IMP_domino.NestedRigidBodyStates_get_transformation(self, i)

    def get_version_info(self):
        r"""get_version_info(NestedRigidBodyStates self) -> VersionInfo"""
        return _IMP_domino.NestedRigidBodyStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_NestedRigidBodyStates

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

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

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


# Register NestedRigidBodyStates in _IMP_domino:
_IMP_domino.NestedRigidBodyStates_swigregister(NestedRigidBodyStates)
class CompoundStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::CompoundStates class."""

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

    def __init__(self, a, b):
        r"""__init__(CompoundStates self, ParticleStates a, ParticleStates b) -> CompoundStates"""
        _IMP_domino.CompoundStates_swiginit(self, _IMP_domino.new_CompoundStates(a, b))

    def get_version_info(self):
        r"""get_version_info(CompoundStates self) -> VersionInfo"""
        return _IMP_domino.CompoundStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_CompoundStates

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

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

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


# Register CompoundStates in _IMP_domino:
_IMP_domino.CompoundStates_swigregister(CompoundStates)
class RecursiveStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::RecursiveStates class."""

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

    def __init__(self, p, s, ss, pst):
        r"""__init__(RecursiveStates self, Particle p, Subset s, IMP::domino::Assignments const & ss, ParticleStatesTable pst) -> RecursiveStates"""
        _IMP_domino.RecursiveStates_swiginit(self, _IMP_domino.new_RecursiveStates(p, s, ss, pst))

    def get_version_info(self):
        r"""get_version_info(RecursiveStates self) -> VersionInfo"""
        return _IMP_domino.RecursiveStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_RecursiveStates

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

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

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


# Register RecursiveStates in _IMP_domino:
_IMP_domino.RecursiveStates_swigregister(RecursiveStates)
class PermutationStates(ParticleStates):
    r"""Proxy of C++ IMP::domino::PermutationStates class."""

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

    def __init__(self, inner):
        r"""__init__(PermutationStates self, ParticleStates inner) -> PermutationStates"""
        _IMP_domino.PermutationStates_swiginit(self, _IMP_domino.new_PermutationStates(inner))

    def get_inner_state(self, i):
        r"""get_inner_state(PermutationStates self, unsigned int i) -> unsigned int"""
        return _IMP_domino.PermutationStates_get_inner_state(self, i)

    def get_version_info(self):
        r"""get_version_info(PermutationStates self) -> VersionInfo"""
        return _IMP_domino.PermutationStates_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_PermutationStates

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

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

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


# Register PermutationStates in _IMP_domino:
_IMP_domino.PermutationStates_swigregister(PermutationStates)
class _ParticlesAdaptor(IMP._InputAdaptor):
    r"""Proxy of C++ IMP::domino::ParticlesAdaptor class."""

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

    def __init__(self, *args):
        r"""
        ParticlesAdaptor(ParticleStatesTable pst) -> _ParticlesAdaptor
        __init__(_ParticlesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticlesAdaptor
        """
        _IMP_domino._ParticlesAdaptor_swiginit(self, _IMP_domino.new__ParticlesAdaptor(*args))
    __swig_destroy__ = _IMP_domino.delete__ParticlesAdaptor

# Register _ParticlesAdaptor in _IMP_domino:
_IMP_domino._ParticlesAdaptor_swigregister(_ParticlesAdaptor)
class RestraintCache(IMP.Object):
    r"""Proxy of C++ IMP::domino::RestraintCache class."""

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

    def __init__(self, *args):
        r"""__init__(RestraintCache self, ParticleStatesTable pst, unsigned int size=std::numeric_limits< unsigned int >::max()) -> RestraintCache"""
        _IMP_domino.RestraintCache_swiginit(self, _IMP_domino.new_RestraintCache(*args))

    def add_restraints(self, rs):
        r"""add_restraints(RestraintCache self, _RestraintsAdaptor rs)"""
        return _IMP_domino.RestraintCache_add_restraints(self, rs)

    def get_score(self, *args):
        r"""
        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, r, s, a):
        r"""load_last_score(RestraintCache self, Restraint r, Subset s, Assignment a)"""
        return _IMP_domino.RestraintCache_load_last_score(self, r, s, a)

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

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

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(RestraintCache self) -> VersionInfo"""
        return _IMP_domino.RestraintCache_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_RestraintCache

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

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

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


# Register RestraintCache in _IMP_domino:
_IMP_domino.RestraintCache_swigregister(RestraintCache)
class SubsetFilter(IMP.Object):
    r"""Proxy of C++ IMP::domino::SubsetFilter class."""

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

    def __init__(self, *args):
        r"""__init__(SubsetFilter self, std::string name="SubsetFilter%1%") -> SubsetFilter"""
        if self.__class__ == SubsetFilter:
            _self = None
        else:
            _self = self
        _IMP_domino.SubsetFilter_swiginit(self, _IMP_domino.new_SubsetFilter(_self, *args))

        if self.__class__ != SubsetFilter:
            _director_objects.register(self)




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

    def get_next_state(self, pos, state):
        r"""get_next_state(SubsetFilter self, int pos, Assignment state) -> int"""
        return _IMP_domino.SubsetFilter_get_next_state(self, pos, state)
    __swig_destroy__ = _IMP_domino.delete_SubsetFilter

    def __str__(self):
        r"""__str__(SubsetFilter self) -> std::string"""
        return _IMP_domino.SubsetFilter___str__(self)

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

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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SubsetFilter(o)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_SubsetFilter(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(SubsetFilter self)"""
        return _IMP_domino.SubsetFilter_do_destroy(self)

# Register SubsetFilter in _IMP_domino:
_IMP_domino.SubsetFilter_swigregister(SubsetFilter)
class SubsetFilterTable(IMP.Object):
    r"""Proxy of C++ IMP::domino::SubsetFilterTable class."""

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

    def __init__(self, *args):
        r"""__init__(SubsetFilterTable self, std::string name="SubsetFilterTable%1%") -> SubsetFilterTable"""
        if self.__class__ == SubsetFilterTable:
            _self = None
        else:
            _self = self
        _IMP_domino.SubsetFilterTable_swiginit(self, _IMP_domino.new_SubsetFilterTable(_self, *args))

        if self.__class__ != SubsetFilterTable:
            _director_objects.register(self)




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

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

    def __str__(self):
        r"""__str__(SubsetFilterTable self) -> std::string"""
        return _IMP_domino.SubsetFilterTable___str__(self)

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

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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SubsetFilterTable(o)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_SubsetFilterTable(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(SubsetFilterTable self)"""
        return _IMP_domino.SubsetFilterTable_do_destroy(self)

# Register SubsetFilterTable in _IMP_domino:
_IMP_domino.SubsetFilterTable_swigregister(SubsetFilterTable)
class RestraintScoreSubsetFilterTable(SubsetFilterTable):
    r"""Proxy of C++ IMP::domino::RestraintScoreSubsetFilterTable class."""

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

    def __init__(self, *args):
        r"""
        __init__(RestraintScoreSubsetFilterTable self, RestraintCache rc) -> RestraintScoreSubsetFilterTable
        __init__(RestraintScoreSubsetFilterTable self, _RestraintsAdaptor rs, ParticleStatesTable pst) -> RestraintScoreSubsetFilterTable
        """
        _IMP_domino.RestraintScoreSubsetFilterTable_swiginit(self, _IMP_domino.new_RestraintScoreSubsetFilterTable(*args))

    def get_version_info(self):
        r"""get_version_info(RestraintScoreSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.RestraintScoreSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_RestraintScoreSubsetFilterTable

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

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

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


# Register RestraintScoreSubsetFilterTable in _IMP_domino:
_IMP_domino.RestraintScoreSubsetFilterTable_swigregister(RestraintScoreSubsetFilterTable)
class MinimumRestraintScoreSubsetFilterTable(SubsetFilterTable):
    r"""Proxy of C++ IMP::domino::MinimumRestraintScoreSubsetFilterTable class."""

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

    def __init__(self, rs, rc, max_number_allowed_violations):
        r"""__init__(MinimumRestraintScoreSubsetFilterTable self, IMP::RestraintsTemp const & rs, RestraintCache rc, int max_number_allowed_violations) -> MinimumRestraintScoreSubsetFilterTable"""
        _IMP_domino.MinimumRestraintScoreSubsetFilterTable_swiginit(self, _IMP_domino.new_MinimumRestraintScoreSubsetFilterTable(rs, rc, max_number_allowed_violations))

    def get_maximum_number_of_violated_restraints(self):
        r"""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):
        r"""get_version_info(MinimumRestraintScoreSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.MinimumRestraintScoreSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_MinimumRestraintScoreSubsetFilterTable

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

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

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


# Register MinimumRestraintScoreSubsetFilterTable in _IMP_domino:
_IMP_domino.MinimumRestraintScoreSubsetFilterTable_swigregister(MinimumRestraintScoreSubsetFilterTable)
class DisjointSetsSubsetFilterTable(SubsetFilterTable):
    r"""Proxy of C++ IMP::domino::DisjointSetsSubsetFilterTable class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")

    def add_set(self, ps):
        r"""add_set(DisjointSetsSubsetFilterTable self, IMP::ParticlesTemp const & ps)"""
        return _IMP_domino.DisjointSetsSubsetFilterTable_add_set(self, ps)

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

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

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

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

    __swig_destroy__ = _IMP_domino.delete_DisjointSetsSubsetFilterTable

# Register DisjointSetsSubsetFilterTable in _IMP_domino:
_IMP_domino.DisjointSetsSubsetFilterTable_swigregister(DisjointSetsSubsetFilterTable)
class ExclusionSubsetFilterTable(DisjointSetsSubsetFilterTable):
    r"""Proxy of C++ IMP::domino::ExclusionSubsetFilterTable class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExclusionSubsetFilterTable self, ParticleStatesTable pst) -> ExclusionSubsetFilterTable
        __init__(ExclusionSubsetFilterTable self) -> ExclusionSubsetFilterTable
        """
        _IMP_domino.ExclusionSubsetFilterTable_swiginit(self, _IMP_domino.new_ExclusionSubsetFilterTable(*args))

    def get_version_info(self):
        r"""get_version_info(ExclusionSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.ExclusionSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ExclusionSubsetFilterTable

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

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

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


# Register ExclusionSubsetFilterTable in _IMP_domino:
_IMP_domino.ExclusionSubsetFilterTable_swigregister(ExclusionSubsetFilterTable)
class EqualitySubsetFilterTable(DisjointSetsSubsetFilterTable):
    r"""Proxy of C++ IMP::domino::EqualitySubsetFilterTable class."""

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

    def __init__(self, *args):
        r"""
        __init__(EqualitySubsetFilterTable self, ParticleStatesTable pst) -> EqualitySubsetFilterTable
        __init__(EqualitySubsetFilterTable self) -> EqualitySubsetFilterTable
        """
        _IMP_domino.EqualitySubsetFilterTable_swiginit(self, _IMP_domino.new_EqualitySubsetFilterTable(*args))

    def get_version_info(self):
        r"""get_version_info(EqualitySubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.EqualitySubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_EqualitySubsetFilterTable

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

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

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


# Register EqualitySubsetFilterTable in _IMP_domino:
_IMP_domino.EqualitySubsetFilterTable_swigregister(EqualitySubsetFilterTable)
class EquivalenceSubsetFilterTable(DisjointSetsSubsetFilterTable):
    r"""Proxy of C++ IMP::domino::EquivalenceSubsetFilterTable class."""

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

    def __init__(self, *args):
        r"""
        __init__(EquivalenceSubsetFilterTable self, ParticleStatesTable pst) -> EquivalenceSubsetFilterTable
        __init__(EquivalenceSubsetFilterTable self) -> EquivalenceSubsetFilterTable
        """
        _IMP_domino.EquivalenceSubsetFilterTable_swiginit(self, _IMP_domino.new_EquivalenceSubsetFilterTable(*args))

    def get_version_info(self):
        r"""get_version_info(EquivalenceSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.EquivalenceSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_EquivalenceSubsetFilterTable

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

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

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


# Register EquivalenceSubsetFilterTable in _IMP_domino:
_IMP_domino.EquivalenceSubsetFilterTable_swigregister(EquivalenceSubsetFilterTable)
class EquivalenceAndExclusionSubsetFilterTable(DisjointSetsSubsetFilterTable):
    r"""Proxy of C++ IMP::domino::EquivalenceAndExclusionSubsetFilterTable class."""

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

    def __init__(self, *args):
        r"""
        __init__(EquivalenceAndExclusionSubsetFilterTable self, ParticleStatesTable pst) -> EquivalenceAndExclusionSubsetFilterTable
        __init__(EquivalenceAndExclusionSubsetFilterTable self) -> EquivalenceAndExclusionSubsetFilterTable
        """
        _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_swiginit(self, _IMP_domino.new_EquivalenceAndExclusionSubsetFilterTable(*args))

    def get_version_info(self):
        r"""get_version_info(EquivalenceAndExclusionSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.EquivalenceAndExclusionSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_EquivalenceAndExclusionSubsetFilterTable

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

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

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


# Register EquivalenceAndExclusionSubsetFilterTable in _IMP_domino:
_IMP_domino.EquivalenceAndExclusionSubsetFilterTable_swigregister(EquivalenceAndExclusionSubsetFilterTable)
class ListSubsetFilterTable(SubsetFilterTable):
    r"""Proxy of C++ IMP::domino::ListSubsetFilterTable class."""

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

    def __init__(self, pst):
        r"""__init__(ListSubsetFilterTable self, ParticleStatesTable pst) -> ListSubsetFilterTable"""
        _IMP_domino.ListSubsetFilterTable_swiginit(self, _IMP_domino.new_ListSubsetFilterTable(pst))

    def get_ok_rate(self):
        r"""get_ok_rate(ListSubsetFilterTable self) -> double"""
        return _IMP_domino.ListSubsetFilterTable_get_ok_rate(self)

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

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

    def get_version_info(self):
        r"""get_version_info(ListSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.ListSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ListSubsetFilterTable

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

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

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


# Register ListSubsetFilterTable in _IMP_domino:
_IMP_domino.ListSubsetFilterTable_swigregister(ListSubsetFilterTable)
class PairListSubsetFilterTable(SubsetFilterTable):
    r"""Proxy of C++ IMP::domino::PairListSubsetFilterTable class."""

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

    def __init__(self):
        r"""__init__(PairListSubsetFilterTable self) -> PairListSubsetFilterTable"""
        _IMP_domino.PairListSubsetFilterTable_swiginit(self, _IMP_domino.new_PairListSubsetFilterTable())

    def set_allowed_states(self, p, states):
        r"""set_allowed_states(PairListSubsetFilterTable self, IMP::ParticlePair p, IMP::IntPairs const & states)"""
        return _IMP_domino.PairListSubsetFilterTable_set_allowed_states(self, p, states)

    def get_version_info(self):
        r"""get_version_info(PairListSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.PairListSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_PairListSubsetFilterTable

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

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

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


# Register PairListSubsetFilterTable in _IMP_domino:
_IMP_domino.PairListSubsetFilterTable_swigregister(PairListSubsetFilterTable)
class ProbabilisticSubsetFilterTable(SubsetFilterTable):
    r"""Proxy of C++ IMP::domino::ProbabilisticSubsetFilterTable class."""

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

    def __init__(self, p, leaves_only=False):
        r"""__init__(ProbabilisticSubsetFilterTable self, double p, bool leaves_only=False) -> ProbabilisticSubsetFilterTable"""
        _IMP_domino.ProbabilisticSubsetFilterTable_swiginit(self, _IMP_domino.new_ProbabilisticSubsetFilterTable(p, leaves_only))

    def get_version_info(self):
        r"""get_version_info(ProbabilisticSubsetFilterTable self) -> VersionInfo"""
        return _IMP_domino.ProbabilisticSubsetFilterTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ProbabilisticSubsetFilterTable

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

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

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


# Register ProbabilisticSubsetFilterTable in _IMP_domino:
_IMP_domino.ProbabilisticSubsetFilterTable_swigregister(ProbabilisticSubsetFilterTable)
class AssignmentContainer(IMP.Object):
    r"""Proxy of C++ IMP::domino::AssignmentContainer class."""

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

    def __init__(self, *args):
        r"""__init__(AssignmentContainer self, std::string name="AssignmentContainer %1%") -> AssignmentContainer"""
        if self.__class__ == AssignmentContainer:
            _self = None
        else:
            _self = self
        _IMP_domino.AssignmentContainer_swiginit(self, _IMP_domino.new_AssignmentContainer(_self, *args))

        if self.__class__ != AssignmentContainer:
            _director_objects.register(self)




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

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

    def get_assignments(self, *args):
        r"""
        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, a):
        r"""add_assignment(AssignmentContainer self, Assignment a)"""
        return _IMP_domino.AssignmentContainer_add_assignment(self, a)

    def add_assignments(self, asgn):
        r"""add_assignments(AssignmentContainer self, IMP::domino::Assignments const & asgn)"""
        return _IMP_domino.AssignmentContainer_add_assignments(self, asgn)

    def get_particle_assignments(self, i):
        r"""get_particle_assignments(AssignmentContainer self, unsigned int i) -> IMP::Ints"""
        return _IMP_domino.AssignmentContainer_get_particle_assignments(self, i)
    __swig_destroy__ = _IMP_domino.delete_AssignmentContainer

    def __str__(self):
        r"""__str__(AssignmentContainer self) -> std::string"""
        return _IMP_domino.AssignmentContainer___str__(self)

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

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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_AssignmentContainer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_AssignmentContainer(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(AssignmentContainer self)"""
        return _IMP_domino.AssignmentContainer_do_destroy(self)

# Register AssignmentContainer in _IMP_domino:
_IMP_domino.AssignmentContainer_swigregister(AssignmentContainer)
class PackedAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::PackedAssignmentContainer class."""

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

    def __init__(self, *args):
        r"""__init__(PackedAssignmentContainer self, std::string name="PackedAssignmentContainer %1%") -> PackedAssignmentContainer"""
        _IMP_domino.PackedAssignmentContainer_swiginit(self, _IMP_domino.new_PackedAssignmentContainer(*args))

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(PackedAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.PackedAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_PackedAssignmentContainer

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

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

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


# Register PackedAssignmentContainer in _IMP_domino:
_IMP_domino.PackedAssignmentContainer_swigregister(PackedAssignmentContainer)
class ListAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::ListAssignmentContainer class."""

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

    def __init__(self, *args):
        r"""__init__(ListAssignmentContainer self, std::string name="ListAssignmentContainer %1%") -> ListAssignmentContainer"""
        _IMP_domino.ListAssignmentContainer_swiginit(self, _IMP_domino.new_ListAssignmentContainer(*args))

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(ListAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.ListAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ListAssignmentContainer

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

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

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


# Register ListAssignmentContainer in _IMP_domino:
_IMP_domino.ListAssignmentContainer_swigregister(ListAssignmentContainer)
class SampleAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::SampleAssignmentContainer class."""

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

    def __init__(self, *args):
        r"""__init__(SampleAssignmentContainer self, unsigned int k, std::string name="SampleAssignmentContainer %1%") -> SampleAssignmentContainer"""
        _IMP_domino.SampleAssignmentContainer_swiginit(self, _IMP_domino.new_SampleAssignmentContainer(*args))

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(SampleAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.SampleAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_SampleAssignmentContainer

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

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

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


# Register SampleAssignmentContainer in _IMP_domino:
_IMP_domino.SampleAssignmentContainer_swigregister(SampleAssignmentContainer)
class WriteHDF5AssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::WriteHDF5AssignmentContainer class."""

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

    def __init__(self, *args):
        r"""
        __init__(WriteHDF5AssignmentContainer self, Group parent, Subset s, IMP::ParticlesTemp const & all_particles, std::string name) -> WriteHDF5AssignmentContainer
        __init__(WriteHDF5AssignmentContainer self, IndexDataSet2D dataset, Subset s, IMP::ParticlesTemp const & all_particles, std::string name) -> WriteHDF5AssignmentContainer
        """
        _IMP_domino.WriteHDF5AssignmentContainer_swiginit(self, _IMP_domino.new_WriteHDF5AssignmentContainer(*args))

    def set_cache_size(self, words):
        r"""set_cache_size(WriteHDF5AssignmentContainer self, unsigned int words)"""
        return _IMP_domino.WriteHDF5AssignmentContainer_set_cache_size(self, words)

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(WriteHDF5AssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.WriteHDF5AssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_WriteHDF5AssignmentContainer

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

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

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


# Register WriteHDF5AssignmentContainer in _IMP_domino:
_IMP_domino.WriteHDF5AssignmentContainer_swigregister(WriteHDF5AssignmentContainer)
class ReadHDF5AssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::ReadHDF5AssignmentContainer class."""

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

    def __init__(self, dataset, s, all_particles, name):
        r"""__init__(ReadHDF5AssignmentContainer self, IndexConstDataSet2D dataset, Subset s, IMP::ParticlesTemp const & all_particles, std::string name) -> ReadHDF5AssignmentContainer"""
        _IMP_domino.ReadHDF5AssignmentContainer_swiginit(self, _IMP_domino.new_ReadHDF5AssignmentContainer(dataset, s, all_particles, name))

    def set_cache_size(self, words):
        r"""set_cache_size(ReadHDF5AssignmentContainer self, unsigned int words)"""
        return _IMP_domino.ReadHDF5AssignmentContainer_set_cache_size(self, words)

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(ReadHDF5AssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.ReadHDF5AssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ReadHDF5AssignmentContainer

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

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

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


# Register ReadHDF5AssignmentContainer in _IMP_domino:
_IMP_domino.ReadHDF5AssignmentContainer_swigregister(ReadHDF5AssignmentContainer)
class WriteAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::WriteAssignmentContainer class."""

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

    def __init__(self, out_file, s, all_particles, name):
        r"""__init__(WriteAssignmentContainer self, std::string out_file, Subset s, IMP::ParticlesTemp const & all_particles, std::string name) -> WriteAssignmentContainer"""
        _IMP_domino.WriteAssignmentContainer_swiginit(self, _IMP_domino.new_WriteAssignmentContainer(out_file, s, all_particles, name))

    def set_cache_size(self, words):
        r"""set_cache_size(WriteAssignmentContainer self, unsigned int words)"""
        return _IMP_domino.WriteAssignmentContainer_set_cache_size(self, words)

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(WriteAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.WriteAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_WriteAssignmentContainer

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

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

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


# Register WriteAssignmentContainer in _IMP_domino:
_IMP_domino.WriteAssignmentContainer_swigregister(WriteAssignmentContainer)
class ReadAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::ReadAssignmentContainer class."""

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

    def __init__(self, out_file, s, all_particles, name):
        r"""__init__(ReadAssignmentContainer self, std::string out_file, Subset s, IMP::ParticlesTemp const & all_particles, std::string name) -> ReadAssignmentContainer"""
        _IMP_domino.ReadAssignmentContainer_swiginit(self, _IMP_domino.new_ReadAssignmentContainer(out_file, s, all_particles, name))

    def set_cache_size(self, words):
        r"""set_cache_size(ReadAssignmentContainer self, unsigned int words)"""
        return _IMP_domino.ReadAssignmentContainer_set_cache_size(self, words)

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(ReadAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.ReadAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ReadAssignmentContainer

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

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

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


# Register ReadAssignmentContainer in _IMP_domino:
_IMP_domino.ReadAssignmentContainer_swigregister(ReadAssignmentContainer)
class RangeViewAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::RangeViewAssignmentContainer class."""

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

    def __init__(self, inner, begin, end):
        r"""__init__(RangeViewAssignmentContainer self, AssignmentContainer inner, unsigned int begin, unsigned int end) -> RangeViewAssignmentContainer"""
        _IMP_domino.RangeViewAssignmentContainer_swiginit(self, _IMP_domino.new_RangeViewAssignmentContainer(inner, begin, end))

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(RangeViewAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.RangeViewAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_RangeViewAssignmentContainer

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

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

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


# Register RangeViewAssignmentContainer in _IMP_domino:
_IMP_domino.RangeViewAssignmentContainer_swigregister(RangeViewAssignmentContainer)
class HeapAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::HeapAssignmentContainer class."""

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

    def __init__(self, *args):
        r"""__init__(HeapAssignmentContainer self, Subset subset, unsigned int k, RestraintCache rssf, std::string name="HeapAssignmentContainer %1%") -> HeapAssignmentContainer"""
        _IMP_domino.HeapAssignmentContainer_swiginit(self, _IMP_domino.new_HeapAssignmentContainer(*args))

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(HeapAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.HeapAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_HeapAssignmentContainer

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

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

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


# Register HeapAssignmentContainer in _IMP_domino:
_IMP_domino.HeapAssignmentContainer_swigregister(HeapAssignmentContainer)
class CappedAssignmentContainer(AssignmentContainer):
    r"""Proxy of C++ IMP::domino::CappedAssignmentContainer class."""

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

    def __init__(self, contained, max_states, name):
        r"""__init__(CappedAssignmentContainer self, AssignmentContainer contained, int max_states, std::string name) -> CappedAssignmentContainer"""
        _IMP_domino.CappedAssignmentContainer_swiginit(self, _IMP_domino.new_CappedAssignmentContainer(contained, max_states, name))

    def get_assignments(self, *args):
        r"""
        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):
        r"""get_version_info(CappedAssignmentContainer self) -> VersionInfo"""
        return _IMP_domino.CappedAssignmentContainer_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_CappedAssignmentContainer

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

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

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


# Register CappedAssignmentContainer in _IMP_domino:
_IMP_domino.CappedAssignmentContainer_swigregister(CappedAssignmentContainer)
class AssignmentsTable(IMP.Object):
    r"""Proxy of C++ IMP::domino::AssignmentsTable class."""

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

    def __init__(self, *args):
        r"""__init__(AssignmentsTable self, std::string name="AssignmentsTable %1%") -> AssignmentsTable"""
        if self.__class__ == AssignmentsTable:
            _self = None
        else:
            _self = self
        _IMP_domino.AssignmentsTable_swiginit(self, _IMP_domino.new_AssignmentsTable(_self, *args))

        if self.__class__ != AssignmentsTable:
            _director_objects.register(self)




    def load_assignments(self, s, ac):
        r"""load_assignments(AssignmentsTable self, Subset s, AssignmentContainer ac)"""
        return _IMP_domino.AssignmentsTable_load_assignments(self, s, ac)
    __swig_destroy__ = _IMP_domino.delete_AssignmentsTable

    def __str__(self):
        r"""__str__(AssignmentsTable self) -> std::string"""
        return _IMP_domino.AssignmentsTable___str__(self)

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

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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_AssignmentsTable(o)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_AssignmentsTable(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(AssignmentsTable self)"""
        return _IMP_domino.AssignmentsTable_do_destroy(self)

# Register AssignmentsTable in _IMP_domino:
_IMP_domino.AssignmentsTable_swigregister(AssignmentsTable)
class SimpleAssignmentsTable(AssignmentsTable):
    r"""Proxy of C++ IMP::domino::SimpleAssignmentsTable class."""

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

    def __init__(self, *args):
        r"""__init__(SimpleAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(), unsigned int max=std::numeric_limits< unsigned int >::max()) -> SimpleAssignmentsTable"""
        _IMP_domino.SimpleAssignmentsTable_swiginit(self, _IMP_domino.new_SimpleAssignmentsTable(*args))

    def get_version_info(self):
        r"""get_version_info(SimpleAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.SimpleAssignmentsTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_SimpleAssignmentsTable

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

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

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


# Register SimpleAssignmentsTable in _IMP_domino:
_IMP_domino.SimpleAssignmentsTable_swigregister(SimpleAssignmentsTable)
class RecursiveAssignmentsTable(AssignmentsTable):
    r"""Proxy of C++ IMP::domino::RecursiveAssignmentsTable class."""

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

    def __init__(self, *args):
        r"""__init__(RecursiveAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(), unsigned int max=std::numeric_limits< unsigned int >::max()) -> RecursiveAssignmentsTable"""
        _IMP_domino.RecursiveAssignmentsTable_swiginit(self, _IMP_domino.new_RecursiveAssignmentsTable(*args))

    def get_version_info(self):
        r"""get_version_info(RecursiveAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.RecursiveAssignmentsTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_RecursiveAssignmentsTable

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

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

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


# Register RecursiveAssignmentsTable in _IMP_domino:
_IMP_domino.RecursiveAssignmentsTable_swigregister(RecursiveAssignmentsTable)
class BranchAndBoundAssignmentsTable(AssignmentsTable):
    r"""Proxy of C++ IMP::domino::BranchAndBoundAssignmentsTable class."""

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

    def __init__(self, *args):
        r"""__init__(BranchAndBoundAssignmentsTable self, ParticleStatesTable pst, IMP::domino::SubsetFilterTables const & sft=IMP::domino::SubsetFilterTables(), unsigned int max=std::numeric_limits< unsigned int >::max()) -> BranchAndBoundAssignmentsTable"""
        _IMP_domino.BranchAndBoundAssignmentsTable_swiginit(self, _IMP_domino.new_BranchAndBoundAssignmentsTable(*args))

    def get_version_info(self):
        r"""get_version_info(BranchAndBoundAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.BranchAndBoundAssignmentsTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_BranchAndBoundAssignmentsTable

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

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

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


# Register BranchAndBoundAssignmentsTable in _IMP_domino:
_IMP_domino.BranchAndBoundAssignmentsTable_swigregister(BranchAndBoundAssignmentsTable)
class ListAssignmentsTable(AssignmentsTable):
    r"""Proxy of C++ IMP::domino::ListAssignmentsTable class."""

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

    def __init__(self, *args):
        r"""__init__(ListAssignmentsTable self, std::string name="ListAssignmentsTable %1%") -> ListAssignmentsTable"""
        _IMP_domino.ListAssignmentsTable_swiginit(self, _IMP_domino.new_ListAssignmentsTable(*args))

    def set_assignments(self, s, lsc):
        r"""set_assignments(ListAssignmentsTable self, Subset s, AssignmentContainer lsc)"""
        return _IMP_domino.ListAssignmentsTable_set_assignments(self, s, lsc)

    def get_version_info(self):
        r"""get_version_info(ListAssignmentsTable self) -> VersionInfo"""
        return _IMP_domino.ListAssignmentsTable_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_ListAssignmentsTable

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

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

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


# Register ListAssignmentsTable in _IMP_domino:
_IMP_domino.ListAssignmentsTable_swigregister(ListAssignmentsTable)

def get_order(s, sft):
    r"""get_order(Subset s, IMP::domino::SubsetFilterTables const & sft) -> IMP::ParticlesTemp"""
    return _IMP_domino.get_order(s, sft)
class _SubsetGraphVertexIndex(object):
    r"""Proxy of C++ IMP::domino::SubsetGraphVertexIndex class."""

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

    def __init__(self):
        r"""__init__(_SubsetGraphVertexIndex self) -> _SubsetGraphVertexIndex"""
        _IMP_domino._SubsetGraphVertexIndex_swiginit(self, _IMP_domino.new__SubsetGraphVertexIndex())
    __swig_destroy__ = _IMP_domino.delete__SubsetGraphVertexIndex

# Register _SubsetGraphVertexIndex in _IMP_domino:
_IMP_domino._SubsetGraphVertexIndex_swigregister(_SubsetGraphVertexIndex)
class _InteractionGraphVertexIndex(object):
    r"""Proxy of C++ IMP::domino::InteractionGraphVertexIndex class."""

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

    def __init__(self):
        r"""__init__(_InteractionGraphVertexIndex self) -> _InteractionGraphVertexIndex"""
        _IMP_domino._InteractionGraphVertexIndex_swiginit(self, _IMP_domino.new__InteractionGraphVertexIndex())
    __swig_destroy__ = _IMP_domino.delete__InteractionGraphVertexIndex

# Register _InteractionGraphVertexIndex in _IMP_domino:
_IMP_domino._InteractionGraphVertexIndex_swigregister(_InteractionGraphVertexIndex)

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

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

def get_triangulated(input):
    r"""get_triangulated(IMP::domino::InteractionGraph const & input) -> IMP::domino::InteractionGraph"""
    return _IMP_domino.get_triangulated(input)
class _CliqueGraphVertexIndex(object):
    r"""Proxy of C++ IMP::domino::CliqueGraphVertexIndex class."""

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

    def __init__(self):
        r"""__init__(_CliqueGraphVertexIndex self) -> _CliqueGraphVertexIndex"""
        _IMP_domino._CliqueGraphVertexIndex_swiginit(self, _IMP_domino.new__CliqueGraphVertexIndex())
    __swig_destroy__ = _IMP_domino.delete__CliqueGraphVertexIndex

# Register _CliqueGraphVertexIndex in _IMP_domino:
_IMP_domino._CliqueGraphVertexIndex_swigregister(_CliqueGraphVertexIndex)

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

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

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

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

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

def get_subset_graph_geometry(ig):
    r"""get_subset_graph_geometry(IMP::domino::SubsetGraph const & ig) -> IMP::display::Geometries"""
    return _IMP_domino.get_subset_graph_geometry(ig)
class _MergeTreeVertexIndex(object):
    r"""Proxy of C++ IMP::domino::MergeTreeVertexIndex class."""

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

    def __init__(self):
        r"""__init__(_MergeTreeVertexIndex self) -> _MergeTreeVertexIndex"""
        _IMP_domino._MergeTreeVertexIndex_swiginit(self, _IMP_domino.new__MergeTreeVertexIndex())
    __swig_destroy__ = _IMP_domino.delete__MergeTreeVertexIndex

# Register _MergeTreeVertexIndex in _IMP_domino:
_IMP_domino._MergeTreeVertexIndex_swigregister(_MergeTreeVertexIndex)

def show_as_graphviz(*args):
    r"""
    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):
    r"""
    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):
    r"""
    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(junction_tree):
    r"""get_balanced_merge_tree(IMP::domino::SubsetGraph const & junction_tree) -> IMP::domino::MergeTree"""
    return _IMP_domino.get_balanced_merge_tree(junction_tree)

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

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

def read_merge_tree(input, ps):
    r"""read_merge_tree(std::istream & input, IMP::ParticlesTemp const & ps) -> IMP::domino::MergeTree"""
    return _IMP_domino.read_merge_tree(input, ps)
class DiscreteSampler(IMP.Sampler):
    r"""Proxy of C++ IMP::domino::DiscreteSampler class."""

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

    def get_subset_filter_tables_to_use(self, rs, pst):
        r"""get_subset_filter_tables_to_use(DiscreteSampler self, IMP::RestraintsTemp const & rs, ParticleStatesTable pst) -> IMP::domino::SubsetFilterTables"""
        return _IMP_domino.DiscreteSampler_get_subset_filter_tables_to_use(self, rs, pst)

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

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

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

    def get_restraints(self):
        r"""get_restraints(DiscreteSampler self) -> IMP::RestraintsTemp"""
        return _IMP_domino.DiscreteSampler_get_restraints(self)

    def __init__(self, m, pst, name):
        r"""__init__(DiscreteSampler self, Model m, ParticleStatesTable pst, std::string name) -> DiscreteSampler"""
        if self.__class__ == DiscreteSampler:
            _self = None
        else:
            _self = self
        _IMP_domino.DiscreteSampler_swiginit(self, _IMP_domino.new_DiscreteSampler(_self, m, pst, name))

        if self.__class__ != DiscreteSampler:
            _director_objects.register(self)



    __swig_destroy__ = _IMP_domino.delete_DiscreteSampler

    def set_restraints(self, rs):
        r"""set_restraints(DiscreteSampler self, _RestraintsAdaptor rs)"""
        return _IMP_domino.DiscreteSampler_set_restraints(self, rs)

    def set_particle_states(self, p, se):
        r"""set_particle_states(DiscreteSampler self, Particle p, ParticleStates se)"""
        return _IMP_domino.DiscreteSampler_set_particle_states(self, p, se)

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

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

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

    def get_particle_states_table(self):
        r"""get_particle_states_table(DiscreteSampler self) -> ParticleStatesTable"""
        return _IMP_domino.DiscreteSampler_get_particle_states_table(self)
    def __get_subset_filter_tables(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_subset_filter_tables,  getfunc=self.get_subset_filter_table, erasefunc=self.erase_subset_filter_table,  appendfunc=self.add_subset_filter_table, extendfunc=self.add_subset_filter_tables,  clearfunc=self.clear_subset_filter_tables, indexfunc=self._python_index_subset_filter_table)  
    def __set_subset_filter_tables(self, obj): IMP._list_util.set_varlist(self.subset_filter_tables, obj)  
    def __del_subset_filter_tables(self): IMP._list_util.del_varlist(self.subset_filter_tables)       
    subset_filter_tables = property(__get_subset_filter_tables, __set_subset_filter_tables, __del_subset_filter_tables, doc="List of ##ucnames")  

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

    def _python_index_subset_filter_table(self, d, start, stop):
        r"""_python_index_subset_filter_table(DiscreteSampler self, SubsetFilterTable d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_domino.DiscreteSampler__python_index_subset_filter_table(self, d, start, stop)

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

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

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

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

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

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

    def get_number_of_subset_filter_tables(self):
        r"""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):
        r"""get_has_subset_filter_tables(DiscreteSampler self) -> bool"""
        return _IMP_domino.DiscreteSampler_get_has_subset_filter_tables(self)

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

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

    def erase_subset_filter_table(self, i):
        r"""erase_subset_filter_table(DiscreteSampler self, unsigned int i)"""
        return _IMP_domino.DiscreteSampler_erase_subset_filter_table(self, i)

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

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

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

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

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

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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_DiscreteSampler(o)

    def __disown__(self):
        self.this.disown()
        _IMP_domino.disown_DiscreteSampler(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(DiscreteSampler self)"""
        return _IMP_domino.DiscreteSampler_do_destroy(self)

# Register DiscreteSampler in _IMP_domino:
_IMP_domino.DiscreteSampler_swigregister(DiscreteSampler)
class DominoSampler(DiscreteSampler):
    r"""Proxy of C++ IMP::domino::DominoSampler class."""

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

    def __init__(self, *args):
        r"""
        __init__(DominoSampler self, Model m, std::string name="DominoSampler %1%") -> DominoSampler
        __init__(DominoSampler self, Model m, ParticleStatesTable pst, std::string name="DominoSampler %1%") -> DominoSampler
        """
        _IMP_domino.DominoSampler_swiginit(self, _IMP_domino.new_DominoSampler(*args))

    def do_get_sample_assignments(self, known):
        r"""do_get_sample_assignments(DominoSampler self, Subset known) -> IMP::domino::Assignments"""
        return _IMP_domino.DominoSampler_do_get_sample_assignments(self, known)

    def get_version_info(self):
        r"""get_version_info(DominoSampler self) -> VersionInfo"""
        return _IMP_domino.DominoSampler_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_DominoSampler

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

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

    def get_number_of_assignments_for_vertex(self, tree_vertex):
        r"""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, tree_vertex)

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

    def get_vertex_assignments(self, *args):
        r"""
        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 const & first, IMP::domino::Assignments const & second, unsigned int max_states=std::numeric_limits< int >::max()) -> IMP::domino::Assignments
        """
        return _IMP_domino.DominoSampler_get_vertex_assignments(self, *args)

    def load_vertex_assignments(self, *args):
        r"""
        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 first, AssignmentContainer second, AssignmentContainer ac, unsigned int max_states=std::numeric_limits< int >::max())
        """
        return _IMP_domino.DominoSampler_load_vertex_assignments(self, *args)

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

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

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


# Register DominoSampler in _IMP_domino:
_IMP_domino.DominoSampler_swigregister(DominoSampler)
class BranchAndBoundSampler(DiscreteSampler):
    r"""Proxy of C++ IMP::domino::BranchAndBoundSampler class."""

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

    def __init__(self, *args):
        r"""
        __init__(BranchAndBoundSampler self, Model m, std::string name="BranchAndBoundSampler %1%") -> BranchAndBoundSampler
        __init__(BranchAndBoundSampler self, Model m, ParticleStatesTable pst, std::string name="BranchAndBoundSampler %1%") -> BranchAndBoundSampler
        """
        _IMP_domino.BranchAndBoundSampler_swiginit(self, _IMP_domino.new_BranchAndBoundSampler(*args))

    def do_get_sample_assignments(self, known):
        r"""do_get_sample_assignments(BranchAndBoundSampler self, Subset known) -> IMP::domino::Assignments"""
        return _IMP_domino.BranchAndBoundSampler_do_get_sample_assignments(self, known)

    def get_version_info(self):
        r"""get_version_info(BranchAndBoundSampler self) -> VersionInfo"""
        return _IMP_domino.BranchAndBoundSampler_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_BranchAndBoundSampler

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

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

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


# Register BranchAndBoundSampler in _IMP_domino:
_IMP_domino.BranchAndBoundSampler_swigregister(BranchAndBoundSampler)

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

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

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

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

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

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

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

def get_distance_if_smaller_than(s, a, b, pst, metrics, max):
    r"""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(s, a, b, pst, metrics, max)

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

def load_merged_assignments(first_subset, first, second_subset, second, filters, ret):
    r"""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(first_subset, first, second_subset, second, filters, ret)

def load_merged_assignments_random_order(first_subset, first, second_subset, second, filters, maximum_tries, ret):
    r"""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(first_subset, first, second_subset, second, filters, maximum_tries, ret)

def get_state_clusters(subset, states, pst, resolution):
    r"""get_state_clusters(Subset subset, IMP::domino::Assignments const & states, ParticleStatesTable pst, double resolution) -> IMP::domino::Assignments"""
    return _IMP_domino.get_state_clusters(subset, states, pst, resolution)
class DependencyScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::domino::DependencyScoreState class."""

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

    def __init__(self, m):
        r"""__init__(DependencyScoreState self, Model m) -> DependencyScoreState"""
        _IMP_domino.DependencyScoreState_swiginit(self, _IMP_domino.new_DependencyScoreState(m))

    def set_input_particles(self, pt):
        r"""set_input_particles(DependencyScoreState self, IMP::ParticlesTemp const & pt)"""
        return _IMP_domino.DependencyScoreState_set_input_particles(self, pt)

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

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

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

    def get_version_info(self):
        r"""get_version_info(DependencyScoreState self) -> VersionInfo"""
        return _IMP_domino.DependencyScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_domino.delete_DependencyScoreState

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

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

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


# Register DependencyScoreState in _IMP_domino:
_IMP_domino.DependencyScoreState_swigregister(DependencyScoreState)

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

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

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

def get_data_path(fname):
    r"""get_data_path(std::string fname) -> std::string"""
    return _IMP_domino.get_data_path(fname)

from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()