rmf/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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-2015 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import




from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_rmf', [dirname(__file__)])
        except ImportError:
            import _IMP_rmf
            return _IMP_rmf
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_rmf', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_rmf = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_rmf
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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


class IMP_RMF_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_RMF_SwigPyIterator class"""
    thisown = _swig_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_rmf.delete_IMP_RMF_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(IMP_RMF_SwigPyIterator self, size_t n=1) -> IMP_RMF_SwigPyIterator
        incr(IMP_RMF_SwigPyIterator self) -> IMP_RMF_SwigPyIterator
        """
        return _IMP_rmf.IMP_RMF_SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(IMP_RMF_SwigPyIterator self, size_t n=1) -> IMP_RMF_SwigPyIterator
        decr(IMP_RMF_SwigPyIterator self) -> IMP_RMF_SwigPyIterator
        """
        return _IMP_rmf.IMP_RMF_SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> bool"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(IMP_RMF_SwigPyIterator self) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_copy(self)


    def next(self):
        """next(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_next(self)


    def __next__(self):
        """__next__(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___next__(self)


    def previous(self):
        """previous(IMP_RMF_SwigPyIterator self) -> PyObject *"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> bool"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> bool"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator
        __sub__(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_rmf.IMP_RMF_SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
IMP_RMF_SwigPyIterator_swigregister = _IMP_rmf.IMP_RMF_SwigPyIterator_swigregister
IMP_RMF_SwigPyIterator_swigregister(IMP_RMF_SwigPyIterator)

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


_IMP_rmf.IMP_DEBUG_swigconstant(_IMP_rmf)
IMP_DEBUG = _IMP_rmf.IMP_DEBUG

_IMP_rmf.IMP_RELEASE_swigconstant(_IMP_rmf)
IMP_RELEASE = _IMP_rmf.IMP_RELEASE

_IMP_rmf.IMP_SILENT_swigconstant(_IMP_rmf)
IMP_SILENT = _IMP_rmf.IMP_SILENT

_IMP_rmf.IMP_PROGRESS_swigconstant(_IMP_rmf)
IMP_PROGRESS = _IMP_rmf.IMP_PROGRESS

_IMP_rmf.IMP_TERSE_swigconstant(_IMP_rmf)
IMP_TERSE = _IMP_rmf.IMP_TERSE

_IMP_rmf.IMP_VERBOSE_swigconstant(_IMP_rmf)
IMP_VERBOSE = _IMP_rmf.IMP_VERBOSE

_IMP_rmf.IMP_MEMORY_swigconstant(_IMP_rmf)
IMP_MEMORY = _IMP_rmf.IMP_MEMORY

_IMP_rmf.IMP_NONE_swigconstant(_IMP_rmf)
IMP_NONE = _IMP_rmf.IMP_NONE

_IMP_rmf.IMP_USAGE_swigconstant(_IMP_rmf)
IMP_USAGE = _IMP_rmf.IMP_USAGE

_IMP_rmf.IMP_INTERNAL_swigconstant(_IMP_rmf)
IMP_INTERNAL = _IMP_rmf.IMP_INTERNAL

_IMP_rmf.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_rmf)
IMP_KERNEL_HAS_LOG4CXX = _IMP_rmf.IMP_KERNEL_HAS_LOG4CXX

_IMP_rmf.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_rmf)
IMP_COMPILER_HAS_AUTO = _IMP_rmf.IMP_COMPILER_HAS_AUTO

_IMP_rmf.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_rmf)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_rmf.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_rmf.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_rmf.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_rmf.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_rmf)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_rmf.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_rmf.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_rmf)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_rmf.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_rmf.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_rmf)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_rmf.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_rmf.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPKERNEL_SHOW_WARNINGS = _IMP_rmf.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):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_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):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_rmf._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_rmf._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_rmf.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_rmf)
IMP_COMPILER_HAS_OVERRIDE = _IMP_rmf.IMP_COMPILER_HAS_OVERRIDE

_IMP_rmf.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_rmf)
IMP_COMPILER_HAS_FINAL = _IMP_rmf.IMP_COMPILER_HAS_FINAL

_IMP_rmf.IMP_HAS_NOEXCEPT_swigconstant(_IMP_rmf)
IMP_HAS_NOEXCEPT = _IMP_rmf.IMP_HAS_NOEXCEPT
import IMP

_IMP_rmf.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_rmf.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CGAL_HAS_BOOST_SYSTEM

_IMP_rmf.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPCGAL_SHOW_WARNINGS = _IMP_rmf.IMPCGAL_SHOW_WARNINGS
import IMP.cgal

_IMP_rmf.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_rmf.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_rmf.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_rmf.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_CGAL = _IMP_rmf.IMP_ALGEBRA_HAS_CGAL

_IMP_rmf.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_rmf)
IMP_ALGEBRA_HAS_ANN = _IMP_rmf.IMP_ALGEBRA_HAS_ANN

_IMP_rmf.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPALGEBRA_SHOW_WARNINGS = _IMP_rmf.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra

_IMP_rmf.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_rmf.IMP_DISPLAY_HAS_IMP_CGAL

_IMP_rmf.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_RANDOM

_IMP_rmf.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_DISPLAY_HAS_CGAL = _IMP_rmf.IMP_DISPLAY_HAS_CGAL

_IMP_rmf.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPDISPLAY_SHOW_WARNINGS = _IMP_rmf.IMPDISPLAY_SHOW_WARNINGS
import IMP.display

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_CGAL

_IMP_rmf.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_rmf)
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_HDF5

_IMP_rmf.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_rmf.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor

_IMP_rmf.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_CORE_HAS_IMP_CGAL = _IMP_rmf.IMP_CORE_HAS_IMP_CGAL

_IMP_rmf.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_rmf)
IMP_CORE_HAS_IMP_KERNEL = _IMP_rmf.IMP_CORE_HAS_IMP_KERNEL

_IMP_rmf.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CORE_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_CORE_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CORE_HAS_BOOST_RANDOM

_IMP_rmf.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CORE_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_CORE_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_CORE_HAS_CGAL = _IMP_rmf.IMP_CORE_HAS_CGAL

_IMP_rmf.IMP_CORE_HAS_HDF5_swigconstant(_IMP_rmf)
IMP_CORE_HAS_HDF5 = _IMP_rmf.IMP_CORE_HAS_HDF5

_IMP_rmf.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPCORE_SHOW_WARNINGS = _IMP_rmf.IMPCORE_SHOW_WARNINGS
import IMP.core

_IMP_rmf.IMP_CONTAINER_HAS_IMP_ALGEBRA_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_rmf.IMP_CONTAINER_HAS_IMP_ALGEBRA

_IMP_rmf.IMP_CONTAINER_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_rmf.IMP_CONTAINER_HAS_IMP_CGAL

_IMP_rmf.IMP_CONTAINER_HAS_IMP_DISPLAY_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_rmf.IMP_CONTAINER_HAS_IMP_DISPLAY

_IMP_rmf.IMP_CONTAINER_HAS_IMP_KERNEL_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_rmf.IMP_CONTAINER_HAS_IMP_KERNEL

_IMP_rmf.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

_IMP_rmf.IMP_CONTAINER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_CONTAINER_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_RANDOM

_IMP_rmf.IMP_CONTAINER_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_CONTAINER_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_CGAL = _IMP_rmf.IMP_CONTAINER_HAS_CGAL

_IMP_rmf.IMP_CONTAINER_HAS_HDF5_swigconstant(_IMP_rmf)
IMP_CONTAINER_HAS_HDF5 = _IMP_rmf.IMP_CONTAINER_HAS_HDF5

_IMP_rmf.IMPCONTAINER_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPCONTAINER_SHOW_WARNINGS = _IMP_rmf.IMPCONTAINER_SHOW_WARNINGS
import IMP.container

_IMP_rmf.IMP_ATOM_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_IMP_CGAL = _IMP_rmf.IMP_ATOM_HAS_IMP_CGAL

_IMP_rmf.IMP_ATOM_HAS_IMP_KERNEL_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_IMP_KERNEL = _IMP_rmf.IMP_ATOM_HAS_IMP_KERNEL

_IMP_rmf.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

_IMP_rmf.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_ATOM_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ATOM_HAS_BOOST_RANDOM

_IMP_rmf.IMP_ATOM_HAS_BOOST_REGEX_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_BOOST_REGEX = _IMP_rmf.IMP_ATOM_HAS_BOOST_REGEX

_IMP_rmf.IMP_ATOM_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ATOM_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_ATOM_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_CGAL = _IMP_rmf.IMP_ATOM_HAS_CGAL

_IMP_rmf.IMP_ATOM_HAS_HDF5_swigconstant(_IMP_rmf)
IMP_ATOM_HAS_HDF5 = _IMP_rmf.IMP_ATOM_HAS_HDF5

_IMP_rmf.IMPATOM_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPATOM_SHOW_WARNINGS = _IMP_rmf.IMPATOM_SHOW_WARNINGS

_IMP_rmf.IMP_ATOM_TYPE_INDEX_swigconstant(_IMP_rmf)
IMP_ATOM_TYPE_INDEX = _IMP_rmf.IMP_ATOM_TYPE_INDEX

_IMP_rmf.IMP_RESIDUE_TYPE_INDEX_swigconstant(_IMP_rmf)
IMP_RESIDUE_TYPE_INDEX = _IMP_rmf.IMP_RESIDUE_TYPE_INDEX

_IMP_rmf.IMP_HIERARCHY_TYPE_INDEX_swigconstant(_IMP_rmf)
IMP_HIERARCHY_TYPE_INDEX = _IMP_rmf.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom

_IMP_rmf.IMP_RMF_HAS_IMP_CGAL_swigconstant(_IMP_rmf)
IMP_RMF_HAS_IMP_CGAL = _IMP_rmf.IMP_RMF_HAS_IMP_CGAL

_IMP_rmf.IMP_RMF_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_rmf)
IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_RMF_HAS_IMP_SCORE_FUNCTOR

_IMP_rmf.IMP_RMF_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_rmf)
IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_RMF_HAS_BOOST_FILESYSTEM

_IMP_rmf.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_rmf)
IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS

_IMP_rmf.IMP_RMF_HAS_BOOST_RANDOM_swigconstant(_IMP_rmf)
IMP_RMF_HAS_BOOST_RANDOM = _IMP_rmf.IMP_RMF_HAS_BOOST_RANDOM

_IMP_rmf.IMP_RMF_HAS_BOOST_REGEX_swigconstant(_IMP_rmf)
IMP_RMF_HAS_BOOST_REGEX = _IMP_rmf.IMP_RMF_HAS_BOOST_REGEX

_IMP_rmf.IMP_RMF_HAS_BOOST_SYSTEM_swigconstant(_IMP_rmf)
IMP_RMF_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_RMF_HAS_BOOST_SYSTEM

_IMP_rmf.IMP_RMF_HAS_CGAL_swigconstant(_IMP_rmf)
IMP_RMF_HAS_CGAL = _IMP_rmf.IMP_RMF_HAS_CGAL

_IMP_rmf.IMP_RMF_HAS_HDF5_swigconstant(_IMP_rmf)
IMP_RMF_HAS_HDF5 = _IMP_rmf.IMP_RMF_HAS_HDF5

_IMP_rmf.IMPRMF_SHOW_WARNINGS_swigconstant(_IMP_rmf)
IMPRMF_SHOW_WARNINGS = _IMP_rmf.IMPRMF_SHOW_WARNINGS
import RMF
_object_types.append("SaveOptimizerState")


def _object_cast_to_SaveOptimizerState(o):
    """_object_cast_to_SaveOptimizerState(Object o) -> SaveOptimizerState"""
    return _IMP_rmf._object_cast_to_SaveOptimizerState(o)
_object_types.append("LoadLink")


def _object_cast_to_LoadLink(o):
    """_object_cast_to_LoadLink(Object o) -> LoadLink"""
    return _IMP_rmf._object_cast_to_LoadLink(o)
_object_types.append("SaveLink")


def _object_cast_to_SaveLink(o):
    """_object_cast_to_SaveLink(Object o) -> SaveLink"""
    return _IMP_rmf._object_cast_to_SaveLink(o)
_object_types.append("HierarchySaveLink")


def _object_cast_to_HierarchySaveLink(o):
    """_object_cast_to_HierarchySaveLink(Object o) -> HierarchySaveLink"""
    return _IMP_rmf._object_cast_to_HierarchySaveLink(o)
_object_types.append("HierarchyLoadLink")


def _object_cast_to_HierarchyLoadLink(o):
    """_object_cast_to_HierarchyLoadLink(Object o) -> HierarchyLoadLink"""
    return _IMP_rmf._object_cast_to_HierarchyLoadLink(o)
class LoadLink(IMP.Object):
    """Proxy of C++ IMP::rmf::LoadLink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def do_load(self, fh):
        """do_load(LoadLink self, FileConstHandle fh)"""
        return _IMP_rmf.LoadLink_do_load(self, fh)


    def __init__(self, name):
        """__init__(IMP::rmf::LoadLink self, std::string name) -> LoadLink"""
        if self.__class__ == LoadLink:
            _self = None
        else:
            _self = self
        this = _IMP_rmf.new_LoadLink(_self, name)
        try:
            self.this.append(this)
        except:
            self.this = this
        if self.__class__ != LoadLink:
            _director_objects.register(self)




    def load(self, fh):
        """load(LoadLink self, FileConstHandle fh)"""
        return _IMP_rmf.LoadLink_load(self, fh)

    __swig_destroy__ = _IMP_rmf.delete_LoadLink
    __del__ = lambda self: None

    def __str__(self):
        """__str__(LoadLink self) -> std::string"""
        return _IMP_rmf.LoadLink___str__(self)


    def __repr__(self):
        """__repr__(LoadLink self) -> std::string"""
        return _IMP_rmf.LoadLink___repr__(self)

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

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::rmf" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    def get_from(o):
       return _object_cast_to_LoadLink(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_rmf.disown_LoadLink(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(LoadLink self)"""
        return _IMP_rmf.LoadLink_do_destroy(self)

LoadLink_swigregister = _IMP_rmf.LoadLink_swigregister
LoadLink_swigregister(LoadLink)

class SaveLink(IMP.Object):
    """Proxy of C++ IMP::rmf::SaveLink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def do_save(self, hf):
        """do_save(SaveLink self, FileHandle hf)"""
        return _IMP_rmf.SaveLink_do_save(self, hf)


    def __init__(self, name):
        """__init__(IMP::rmf::SaveLink self, std::string name) -> SaveLink"""
        if self.__class__ == SaveLink:
            _self = None
        else:
            _self = self
        this = _IMP_rmf.new_SaveLink(_self, name)
        try:
            self.this.append(this)
        except:
            self.this = this
        if self.__class__ != SaveLink:
            _director_objects.register(self)




    def save(self, fh):
        """save(SaveLink self, FileHandle fh)"""
        return _IMP_rmf.SaveLink_save(self, fh)

    __swig_destroy__ = _IMP_rmf.delete_SaveLink
    __del__ = lambda self: None

    def __str__(self):
        """__str__(SaveLink self) -> std::string"""
        return _IMP_rmf.SaveLink___str__(self)


    def __repr__(self):
        """__repr__(SaveLink self) -> std::string"""
        return _IMP_rmf.SaveLink___repr__(self)

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

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::rmf" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    def get_from(o):
       return _object_cast_to_SaveLink(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_rmf.disown_SaveLink(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(SaveLink self)"""
        return _IMP_rmf.SaveLink_do_destroy(self)

SaveLink_swigregister = _IMP_rmf.SaveLink_swigregister
SaveLink_swigregister(SaveLink)


def add_hierarchies(*args):
    """
    add_hierarchies(FileHandle fh, IMP::atom::Hierarchies const & hs)
    add_hierarchies(NodeHandle fh, IMP::atom::Hierarchies const & hs)
    """
    return _IMP_rmf.add_hierarchies(*args)

def add_hierarchy(fh, hs):
    """add_hierarchy(FileHandle fh, Hierarchy hs)"""
    return _IMP_rmf.add_hierarchy(fh, hs)

def create_hierarchies(fh, m):
    """create_hierarchies(FileConstHandle fh, Model m) -> IMP::atom::Hierarchies"""
    return _IMP_rmf.create_hierarchies(fh, m)

def link_hierarchies(fh, hs):
    """link_hierarchies(FileConstHandle fh, IMP::atom::Hierarchies const & hs)"""
    return _IMP_rmf.link_hierarchies(fh, hs)

def add_restraints(*args):
    """
    add_restraints(FileHandle fh, IMP::Restraints const & hs)
    add_restraints(NodeHandle fh, IMP::Restraints const & hs)
    """
    return _IMP_rmf.add_restraints(*args)

def add_restraint(fh, hs):
    """add_restraint(FileHandle fh, Restraint hs)"""
    return _IMP_rmf.add_restraint(fh, hs)

def create_restraints(fh, m):
    """create_restraints(FileConstHandle fh, Model m) -> IMP::Restraints"""
    return _IMP_rmf.create_restraints(fh, m)

def link_restraints(fh, hs):
    """link_restraints(FileConstHandle fh, IMP::Restraints const & hs)"""
    return _IMP_rmf.link_restraints(fh, hs)

def add_restraints_as_bonds(fh, rs):
    """add_restraints_as_bonds(FileHandle fh, IMP::Restraints const & rs)"""
    return _IMP_rmf.add_restraints_as_bonds(fh, rs)

def set_maximum_number_of_terms(fh, num):
    """set_maximum_number_of_terms(FileHandle fh, unsigned int num)"""
    return _IMP_rmf.set_maximum_number_of_terms(fh, num)

def add_particles(*args):
    """
    add_particles(FileHandle fh, IMP::ParticlesTemp const & hs)
    add_particles(NodeHandle fh, IMP::ParticlesTemp const & hs)
    """
    return _IMP_rmf.add_particles(*args)

def add_particle(fh, hs):
    """add_particle(FileHandle fh, Particle hs)"""
    return _IMP_rmf.add_particle(fh, hs)

def create_particles(fh, m):
    """create_particles(FileConstHandle fh, Model m) -> IMP::ParticlesTemp"""
    return _IMP_rmf.create_particles(fh, m)

def link_particles(fh, hs):
    """link_particles(FileConstHandle fh, IMP::ParticlesTemp const & hs)"""
    return _IMP_rmf.link_particles(fh, hs)

def add_geometries(*args):
    """
    add_geometries(FileHandle file, IMP::display::GeometriesTemp const & r)
    add_geometries(NodeHandle parent, IMP::display::GeometriesTemp const & r)
    """
    return _IMP_rmf.add_geometries(*args)

def add_static_geometries(parent, r):
    """add_static_geometries(FileHandle parent, IMP::display::GeometriesTemp const & r)"""
    return _IMP_rmf.add_static_geometries(parent, r)

def add_geometry(parent, r):
    """add_geometry(FileHandle parent, Geometry r)"""
    return _IMP_rmf.add_geometry(parent, r)

def create_geometries(parent):
    """create_geometries(FileConstHandle parent) -> IMP::display::Geometries"""
    return _IMP_rmf.create_geometries(parent)

def link_geometries(parent, r):
    """link_geometries(FileConstHandle parent, IMP::display::GeometriesTemp const & r)"""
    return _IMP_rmf.link_geometries(parent, r)

def set_association(nh, o, overwrite=False):
    """
    set_association(NodeConstHandle nh, Object o, bool overwrite=False)
    set_association(NodeConstHandle nh, Object o)
    """
    return _IMP_rmf.set_association(nh, o, overwrite)

def get_node_from_association(*args):
    """
    get_node_from_association(FileConstHandle nh, Object oi) -> NodeConstHandle
    get_node_from_association(FileHandle nh, Object oi) -> NodeHandle
    """
    return _IMP_rmf.get_node_from_association(*args)

def get_has_associated_node(nh, oi):
    """get_has_associated_node(FileConstHandle nh, Object oi) -> bool"""
    return _IMP_rmf.get_has_associated_node(nh, oi)
class SaveOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::rmf::SaveOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, fh):
        """__init__(IMP::rmf::SaveOptimizerState self, Model m, FileHandle fh) -> SaveOptimizerState"""
        this = _IMP_rmf.new_SaveOptimizerState(m, fh)
        try:
            self.this.append(this)
        except:
            self.this = this

    def remove_hierarchy(self, d):
        """remove_hierarchy(SaveOptimizerState self, Particle d)"""
        return _IMP_rmf.SaveOptimizerState_remove_hierarchy(self, d)


    def remove_hierarchies(self, d):
        """remove_hierarchies(SaveOptimizerState self, IMP::Particles const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_hierarchies(self, d)


    def set_hierarchies(self, ps):
        """set_hierarchies(SaveOptimizerState self, IMP::Particles const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_hierarchies(self, ps)


    def set_hierarchies_order(self, objs):
        """set_hierarchies_order(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_hierarchies_order(self, objs)


    def add_hierarchy(self, obj):
        """add_hierarchy(SaveOptimizerState self, Particle obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_hierarchy(self, obj)


    def add_hierarchies(self, objs):
        """add_hierarchies(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_hierarchies(self, objs)


    def clear_hierarchies(self):
        """clear_hierarchies(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_hierarchies(self)


    def get_number_of_hierarchies(self):
        """get_number_of_hierarchies(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_hierarchies(self)


    def get_has_hierarchies(self):
        """get_has_hierarchies(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_hierarchies(self)


    def get_hierarchy(self, i):
        """get_hierarchy(SaveOptimizerState self, unsigned int i) -> Particle"""
        return _IMP_rmf.SaveOptimizerState_get_hierarchy(self, i)


    def get_hierarchies(self):
        """get_hierarchies(SaveOptimizerState self) -> IMP::Particles"""
        return _IMP_rmf.SaveOptimizerState_get_hierarchies(self)


    def reserve_hierarchies(self, sz):
        """reserve_hierarchies(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_hierarchies(self, sz)


    def remove_restraint(self, d):
        """remove_restraint(SaveOptimizerState self, Restraint d)"""
        return _IMP_rmf.SaveOptimizerState_remove_restraint(self, d)


    def remove_restraints(self, d):
        """remove_restraints(SaveOptimizerState self, IMP::Restraints const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_restraints(self, d)


    def set_restraints(self, ps):
        """set_restraints(SaveOptimizerState self, IMP::Restraints const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_restraints(self, ps)


    def set_restraints_order(self, objs):
        """set_restraints_order(SaveOptimizerState self, IMP::Restraints const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_restraints_order(self, objs)


    def add_restraint(self, obj):
        """add_restraint(SaveOptimizerState self, Restraint obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_restraint(self, obj)


    def add_restraints(self, objs):
        """add_restraints(SaveOptimizerState self, IMP::Restraints const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_restraints(self, objs)


    def clear_restraints(self):
        """clear_restraints(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_restraints(self)


    def get_number_of_restraints(self):
        """get_number_of_restraints(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_restraints(self)


    def get_has_restraints(self):
        """get_has_restraints(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_restraints(self)


    def get_restraint(self, i):
        """get_restraint(SaveOptimizerState self, unsigned int i) -> Restraint"""
        return _IMP_rmf.SaveOptimizerState_get_restraint(self, i)


    def get_restraints(self):
        """get_restraints(SaveOptimizerState self) -> IMP::Restraints"""
        return _IMP_rmf.SaveOptimizerState_get_restraints(self)


    def reserve_restraints(self, sz):
        """reserve_restraints(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_restraints(self, sz)


    def remove_particle(self, d):
        """remove_particle(SaveOptimizerState self, Particle d)"""
        return _IMP_rmf.SaveOptimizerState_remove_particle(self, d)


    def remove_particles(self, d):
        """remove_particles(SaveOptimizerState self, IMP::Particles const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_particles(self, d)


    def set_particles(self, ps):
        """set_particles(SaveOptimizerState self, IMP::Particles const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_particles(self, ps)


    def set_particles_order(self, objs):
        """set_particles_order(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_particles_order(self, objs)


    def add_particle(self, obj):
        """add_particle(SaveOptimizerState self, Particle obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_particle(self, obj)


    def add_particles(self, objs):
        """add_particles(SaveOptimizerState self, IMP::Particles const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_particles(self, objs)


    def clear_particles(self):
        """clear_particles(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_particles(self)


    def get_number_of_particles(self):
        """get_number_of_particles(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_particles(self)


    def get_has_particles(self):
        """get_has_particles(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_particles(self)


    def get_particle(self, i):
        """get_particle(SaveOptimizerState self, unsigned int i) -> Particle"""
        return _IMP_rmf.SaveOptimizerState_get_particle(self, i)


    def get_particles(self):
        """get_particles(SaveOptimizerState self) -> IMP::Particles"""
        return _IMP_rmf.SaveOptimizerState_get_particles(self)


    def reserve_particles(self, sz):
        """reserve_particles(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_particles(self, sz)


    def remove_geometry(self, d):
        """remove_geometry(SaveOptimizerState self, Geometry d)"""
        return _IMP_rmf.SaveOptimizerState_remove_geometry(self, d)


    def remove_geometries(self, d):
        """remove_geometries(SaveOptimizerState self, IMP::display::Geometries const & d)"""
        return _IMP_rmf.SaveOptimizerState_remove_geometries(self, d)


    def set_geometries(self, ps):
        """set_geometries(SaveOptimizerState self, IMP::display::Geometries const & ps)"""
        return _IMP_rmf.SaveOptimizerState_set_geometries(self, ps)


    def set_geometries_order(self, objs):
        """set_geometries_order(SaveOptimizerState self, IMP::display::Geometries const & objs)"""
        return _IMP_rmf.SaveOptimizerState_set_geometries_order(self, objs)


    def add_geometry(self, obj):
        """add_geometry(SaveOptimizerState self, Geometry obj) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_add_geometry(self, obj)


    def add_geometries(self, objs):
        """add_geometries(SaveOptimizerState self, IMP::display::Geometries const & objs)"""
        return _IMP_rmf.SaveOptimizerState_add_geometries(self, objs)


    def clear_geometries(self):
        """clear_geometries(SaveOptimizerState self)"""
        return _IMP_rmf.SaveOptimizerState_clear_geometries(self)


    def get_number_of_geometries(self):
        """get_number_of_geometries(SaveOptimizerState self) -> unsigned int"""
        return _IMP_rmf.SaveOptimizerState_get_number_of_geometries(self)


    def get_has_geometries(self):
        """get_has_geometries(SaveOptimizerState self) -> bool"""
        return _IMP_rmf.SaveOptimizerState_get_has_geometries(self)


    def get_geometry(self, i):
        """get_geometry(SaveOptimizerState self, unsigned int i) -> Geometry"""
        return _IMP_rmf.SaveOptimizerState_get_geometry(self, i)


    def get_geometries(self):
        """get_geometries(SaveOptimizerState self) -> IMP::display::Geometries"""
        return _IMP_rmf.SaveOptimizerState_get_geometries(self)


    def reserve_geometries(self, sz):
        """reserve_geometries(SaveOptimizerState self, unsigned int sz)"""
        return _IMP_rmf.SaveOptimizerState_reserve_geometries(self, sz)


    def set_simulator(self, sim):
        """set_simulator(SaveOptimizerState self, Simulator sim)"""
        return _IMP_rmf.SaveOptimizerState_set_simulator(self, sim)


    def update_always(self, *args):
        """
        update_always(SaveOptimizerState self, std::string name)
        update_always(SaveOptimizerState self)
        """
        return _IMP_rmf.SaveOptimizerState_update_always(self, *args)


    def do_update(self, call_num):
        """do_update(SaveOptimizerState self, unsigned int call_num)"""
        return _IMP_rmf.SaveOptimizerState_do_update(self, call_num)


    def get_version_info(self):
        """get_version_info(SaveOptimizerState self) -> VersionInfo"""
        return _IMP_rmf.SaveOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(SaveOptimizerState self) -> std::string"""
        return _IMP_rmf.SaveOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(SaveOptimizerState self) -> std::string"""
        return _IMP_rmf.SaveOptimizerState___repr__(self)

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

SaveOptimizerState_swigregister = _IMP_rmf.SaveOptimizerState_swigregister
SaveOptimizerState_swigregister(SaveOptimizerState)


def load_frame(file, frame):
    """load_frame(FileConstHandle file, FrameID frame)"""
    return _IMP_rmf.load_frame(file, frame)

def save_frame(*args):
    """
    save_frame(FileHandle file, std::string name) -> FrameID
    save_frame(FileHandle file) -> FrameID
    """
    return _IMP_rmf.save_frame(*args)
class _ParticleSaveLink(SaveLink):
    """Proxy of C++ IMP::rmf::SimpleSaveLink<(IMP::Particle)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def add(self, parent, os):
        """add(_ParticleSaveLink self, NodeHandle parent, IMP::Vector< Pointer< IMP::Particle > > const & os)"""
        return _IMP_rmf._ParticleSaveLink_add(self, parent, os)

    __swig_destroy__ = _IMP_rmf.delete__ParticleSaveLink
    __del__ = lambda self: None
_ParticleSaveLink_swigregister = _IMP_rmf._ParticleSaveLink_swigregister
_ParticleSaveLink_swigregister(_ParticleSaveLink)

class _ParticleLoadLink(LoadLink):
    """Proxy of C++ IMP::rmf::SimpleLoadLink<(IMP::Particle)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def create(self, *args):
        """
        create(_ParticleLoadLink self, NodeConstHandle rt) -> IMP::Vector< Pointer< IMP::Particle > >
        create(_ParticleLoadLink self, NodeConstHandle rt, Model m) -> IMP::Vector< Pointer< IMP::Particle > >
        """
        return _IMP_rmf._ParticleLoadLink_create(self, *args)


    def link(self, rt, ps):
        """link(_ParticleLoadLink self, NodeConstHandle rt, IMP::Vector< Pointer< IMP::Particle > > const & ps)"""
        return _IMP_rmf._ParticleLoadLink_link(self, rt, ps)

    __swig_destroy__ = _IMP_rmf.delete__ParticleLoadLink
    __del__ = lambda self: None
_ParticleLoadLink_swigregister = _IMP_rmf._ParticleLoadLink_swigregister
_ParticleLoadLink_swigregister(_ParticleLoadLink)

class HierarchyLoadLink(_ParticleLoadLink):
    """Proxy of C++ IMP::rmf::HierarchyLoadLink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, fh):
        """__init__(IMP::rmf::HierarchyLoadLink self, FileConstHandle fh) -> HierarchyLoadLink"""
        this = _IMP_rmf.new_HierarchyLoadLink(fh)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_name():
        """get_name() -> char const *"""
        return _IMP_rmf.HierarchyLoadLink_get_name()

    get_name = staticmethod(get_name)

    def get_version_info(self):
        """get_version_info(HierarchyLoadLink self) -> VersionInfo"""
        return _IMP_rmf.HierarchyLoadLink_get_version_info(self)


    def __str__(self):
        """__str__(HierarchyLoadLink self) -> std::string"""
        return _IMP_rmf.HierarchyLoadLink___str__(self)


    def __repr__(self):
        """__repr__(HierarchyLoadLink self) -> std::string"""
        return _IMP_rmf.HierarchyLoadLink___repr__(self)

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

HierarchyLoadLink_swigregister = _IMP_rmf.HierarchyLoadLink_swigregister
HierarchyLoadLink_swigregister(HierarchyLoadLink)

def HierarchyLoadLink_get_name():
    """HierarchyLoadLink_get_name() -> char const *"""
    return _IMP_rmf.HierarchyLoadLink_get_name()

class HierarchySaveLink(_ParticleSaveLink):
    """Proxy of C++ IMP::rmf::HierarchySaveLink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, fh):
        """__init__(IMP::rmf::HierarchySaveLink self, FileHandle fh) -> HierarchySaveLink"""
        this = _IMP_rmf.new_HierarchySaveLink(fh)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_name():
        """get_name() -> char const *"""
        return _IMP_rmf.HierarchySaveLink_get_name()

    get_name = staticmethod(get_name)

    def get_version_info(self):
        """get_version_info(HierarchySaveLink self) -> VersionInfo"""
        return _IMP_rmf.HierarchySaveLink_get_version_info(self)


    def __str__(self):
        """__str__(HierarchySaveLink self) -> std::string"""
        return _IMP_rmf.HierarchySaveLink___str__(self)


    def __repr__(self):
        """__repr__(HierarchySaveLink self) -> std::string"""
        return _IMP_rmf.HierarchySaveLink___repr__(self)

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

HierarchySaveLink_swigregister = _IMP_rmf.HierarchySaveLink_swigregister
HierarchySaveLink_swigregister(HierarchySaveLink)

def HierarchySaveLink_get_name():
    """HierarchySaveLink_get_name() -> char const *"""
    return _IMP_rmf.HierarchySaveLink_get_name()

suffixes = [".rmf", ".rmfz"]


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

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

def get_data_path(fname):
    """get_data_path(std::string fname) -> std::string"""
    return _IMP_rmf.get_data_path(fname)
from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()