rmf/__init__.py

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



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


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


class IMP_RMF_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_RMF_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_RMF_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_RMF_SwigPyIterator, name)
    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, *args):
        """distance(IMP_RMF_SwigPyIterator self, IMP_RMF_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_distance(self, *args)

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

    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, *args):
        """advance(IMP_RMF_SwigPyIterator self, ptrdiff_t n) -> IMP_RMF_SwigPyIterator"""
        return _IMP_rmf.IMP_RMF_SwigPyIterator_advance(self, *args)

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

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

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

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

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

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

DEFAULT_CHECK = _IMP_rmf.DEFAULT_CHECK
NONE = _IMP_rmf.NONE
USAGE = _IMP_rmf.USAGE
USAGE_AND_INTERNAL = _IMP_rmf.USAGE_AND_INTERNAL

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

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

_ostream_swigregister = _IMP_rmf._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_rmf.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_rmf.IMP_COMPILER_HAS_FINAL
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CGAL_HAS_BOOST_SYSTEM
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_rmf.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_rmf.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_rmf.IMP_ALGEBRA_HAS_ANN
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_rmf.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_rmf.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_rmf.IMP_KERNEL_HAS_CGAL
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_rmf.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_rmf.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_rmf.IMP_DISPLAY_HAS_CGAL
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_rmf.IMP_SCORE_FUNCTOR_HAS_CGAL
import IMP.score_functor
IMP_CORE_HAS_IMP_BASE = _IMP_rmf.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_rmf.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_rmf.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_rmf.IMP_CORE_HAS_CGAL
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_rmf.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_rmf.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_rmf.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_rmf.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_rmf.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_rmf.IMP_CONTAINER_HAS_CGAL
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_rmf.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_rmf.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_rmf.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_rmf.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_rmf.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_rmf.IMP_ATOM_HAS_CGAL
IMP_ATOM_TYPE_INDEX = _IMP_rmf.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_rmf.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_rmf.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_RMF_HAS_IMP_BASE = _IMP_rmf.IMP_RMF_HAS_IMP_BASE
IMP_RMF_HAS_IMP_CGAL = _IMP_rmf.IMP_RMF_HAS_IMP_CGAL
IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_rmf.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_rmf.IMP_RMF_HAS_BOOST_FILESYSTEM
IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_rmf.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
IMP_RMF_HAS_BOOST_RANDOM = _IMP_rmf.IMP_RMF_HAS_BOOST_RANDOM
IMP_RMF_HAS_BOOST_REGEX = _IMP_rmf.IMP_RMF_HAS_BOOST_REGEX
IMP_RMF_HAS_BOOST_SYSTEM = _IMP_rmf.IMP_RMF_HAS_BOOST_SYSTEM
IMP_RMF_HAS_CGAL = _IMP_rmf.IMP_RMF_HAS_CGAL
import RMF
_object_types.append("SaveOptimizerState")


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


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


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


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


def _object_cast_to_HierarchyLoadLink(*args):
  """_object_cast_to_HierarchyLoadLink(Object o) -> HierarchyLoadLink"""
  return _IMP_rmf._object_cast_to_HierarchyLoadLink(*args)

def get_load_linker_index(*args):
  """get_load_linker_index(std::string st) -> unsigned int"""
  return _IMP_rmf.get_load_linker_index(*args)

def get_save_linker_index(*args):
  """get_save_linker_index(std::string st) -> unsigned int"""
  return _IMP_rmf.get_save_linker_index(*args)
class LoadLink(IMP.base.Object):
    """Proxy of C++ IMP::rmf::LoadLink class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LoadLink, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LoadLink, name)
    def _do_load(self, *args):
        """_do_load(LoadLink self, FileConstHandle fh)"""
        return _IMP_rmf.LoadLink__do_load(self, *args)

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



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

    __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("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    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)
LoadLink_swigregister = _IMP_rmf.LoadLink_swigregister
LoadLink_swigregister(LoadLink)

class SaveLink(IMP.base.Object):
    """Proxy of C++ IMP::rmf::SaveLink class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SaveLink, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SaveLink, name)
    def _do_save(self, *args):
        """_do_save(SaveLink self, FileHandle hf)"""
        return _IMP_rmf.SaveLink__do_save(self, *args)

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



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

    __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("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    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)
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(*args):
  """add_hierarchy(FileHandle fh, Hierarchy hs)"""
  return _IMP_rmf.add_hierarchy(*args)

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

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

def set_save_forces(*args):
  """set_save_forces(FileHandle fh, bool tf)"""
  return _IMP_rmf.set_save_forces(*args)

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

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

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

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

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

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

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

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

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

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(*args):
  """add_static_geometries(FileHandle parent, IMP::display::GeometriesTemp const & r)"""
  return _IMP_rmf.add_static_geometries(*args)

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

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

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

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

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(*args):
  """get_has_associated_node(FileConstHandle nh, Object oi) -> bool"""
  return _IMP_rmf.get_has_associated_node(*args)

def get_has_linker(*args):
  """get_has_linker(FileConstHandle nh, unsigned int id) -> bool"""
  return _IMP_rmf.get_has_linker(*args)
class SaveOptimizerState(IMP.core.PeriodicOptimizerState):
    """Proxy of C++ IMP::rmf::SaveOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.PeriodicOptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SaveOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.PeriodicOptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SaveOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::rmf::SaveOptimizerState self, FileHandle fh) -> SaveOptimizerState"""
        this = _IMP_rmf.new_SaveOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def remove_hierarchy(self, *args):
        """remove_hierarchy(SaveOptimizerState self, Particle d)"""
        return _IMP_rmf.SaveOptimizerState_remove_hierarchy(self, *args)

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

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

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

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

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

    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, *args):
        """get_hierarchy(SaveOptimizerState self, unsigned int i) -> Particle"""
        return _IMP_rmf.SaveOptimizerState_get_hierarchy(self, *args)

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

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

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

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

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

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

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

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

    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, *args):
        """get_restraint(SaveOptimizerState self, unsigned int i) -> Restraint"""
        return _IMP_rmf.SaveOptimizerState_get_restraint(self, *args)

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

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

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

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

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

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

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

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

    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, *args):
        """get_particle(SaveOptimizerState self, unsigned int i) -> Particle"""
        return _IMP_rmf.SaveOptimizerState_get_particle(self, *args)

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

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

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

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

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

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

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

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

    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, *args):
        """get_geometry(SaveOptimizerState self, unsigned int i) -> Geometry"""
        return _IMP_rmf.SaveOptimizerState_get_geometry(self, *args)

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

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

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

    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, *args):
        """do_update(SaveOptimizerState self, unsigned int call_num)"""
        return _IMP_rmf.SaveOptimizerState_do_update(self, *args)

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

    __swig_destroy__ = _IMP_rmf.delete_SaveOptimizerState
    __del__ = lambda self : None;
    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(*args):
  """load_frame(FileConstHandle file, int frame)"""
  return _IMP_rmf.load_frame(*args)

def save_frame(*args):
  """
    save_frame(FileHandle file, int frame, std::string name="frame")
    save_frame(FileHandle file, int frame)
    """
  return _IMP_rmf.save_frame(*args)
class _ParticleSaveLink(SaveLink):
    """Proxy of C++ IMP::rmf::SimpleSaveLink<(IMP::kernel::Particle)> class"""
    __swig_setmethods__ = {}
    for _s in [SaveLink]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleSaveLink, name, value)
    __swig_getmethods__ = {}
    for _s in [SaveLink]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleSaveLink, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def add(self, *args):
        """add(_ParticleSaveLink self, NodeHandle parent, IMP::base::Vector< IMP::base::Pointer< IMP::kernel::Particle > > const & os)"""
        return _IMP_rmf._ParticleSaveLink_add(self, *args)

    __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::kernel::Particle)> class"""
    __swig_setmethods__ = {}
    for _s in [LoadLink]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ParticleLoadLink, name, value)
    __swig_getmethods__ = {}
    for _s in [LoadLink]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ParticleLoadLink, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def _do_load_one(self, *args):
        """_do_load_one(_ParticleLoadLink self, NodeConstHandle nh, Particle o)"""
        return _IMP_rmf._ParticleLoadLink__do_load_one(self, *args)

    def _do_add_link(self, *args):
        """_do_add_link(_ParticleLoadLink self, Particle arg2, NodeConstHandle arg3)"""
        return _IMP_rmf._ParticleLoadLink__do_add_link(self, *args)

    def _add_link(self, *args):
        """_add_link(_ParticleLoadLink self, Particle o, NodeConstHandle nh)"""
        return _IMP_rmf._ParticleLoadLink__add_link(self, *args)

    def _get_is(self, *args):
        """_get_is(_ParticleLoadLink self, NodeConstHandle nh) -> bool"""
        return _IMP_rmf._ParticleLoadLink__get_is(self, *args)

    def _do_create(self, *args):
        """_do_create(_ParticleLoadLink self, NodeConstHandle nh) -> Particle"""
        return _IMP_rmf._ParticleLoadLink__do_create(self, *args)

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

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

    __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"""
    __swig_setmethods__ = {}
    for _s in [_ParticleLoadLink]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchyLoadLink, name, value)
    __swig_getmethods__ = {}
    for _s in [_ParticleLoadLink]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchyLoadLink, name)
    def _do_load_node(self, *args):
        """_do_load_node(HierarchyLoadLink self, NodeConstHandle nh, Particle o)"""
        return _IMP_rmf.HierarchyLoadLink__do_load_node(self, *args)

    def setup_particle(self, *args):
        """setup_particle(HierarchyLoadLink self, Particle root, NodeConstHandle nh, Particle p, Particle rbp) -> bool"""
        return _IMP_rmf.HierarchyLoadLink_setup_particle(self, *args)

    def _do_create_recursive(self, *args):
        """
        _do_create_recursive(HierarchyLoadLink self, Particle root, NodeConstHandle name, Particle rbp=nullptr) -> Particle
        _do_create_recursive(HierarchyLoadLink self, Particle root, NodeConstHandle name) -> Particle
        """
        return _IMP_rmf.HierarchyLoadLink__do_create_recursive(self, *args)

    def _do_add_link_recursive(self, *args):
        """_do_add_link_recursive(HierarchyLoadLink self, Particle root, Particle o, NodeConstHandle node)"""
        return _IMP_rmf.HierarchyLoadLink__do_add_link_recursive(self, *args)

    def __init__(self, *args): 
        """__init__(IMP::rmf::HierarchyLoadLink self, FileConstHandle fh, Model m) -> HierarchyLoadLink"""
        this = _IMP_rmf.new_HierarchyLoadLink(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(HierarchyLoadLink self) -> VersionInfo"""
        return _IMP_rmf.HierarchyLoadLink_get_version_info(self)

    __swig_destroy__ = _IMP_rmf.delete_HierarchyLoadLink
    __del__ = lambda self : None;
    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)

class HierarchySaveLink(_ParticleSaveLink):
    """Proxy of C++ IMP::rmf::HierarchySaveLink class"""
    __swig_setmethods__ = {}
    for _s in [_ParticleSaveLink]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchySaveLink, name, value)
    __swig_getmethods__ = {}
    for _s in [_ParticleSaveLink]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchySaveLink, name)
    def _do_add_recursive(self, *args):
        """_do_add_recursive(HierarchySaveLink self, Particle root, Particle p, NodeHandle cur)"""
        return _IMP_rmf.HierarchySaveLink__do_add_recursive(self, *args)

    def _do_save_node(self, *args):
        """_do_save_node(HierarchySaveLink self, Particle p, NodeHandle n)"""
        return _IMP_rmf.HierarchySaveLink__do_save_node(self, *args)

    def __init__(self, *args): 
        """__init__(IMP::rmf::HierarchySaveLink self, FileHandle fh) -> HierarchySaveLink"""
        this = _IMP_rmf.new_HierarchySaveLink(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(HierarchySaveLink self) -> VersionInfo"""
        return _IMP_rmf.HierarchySaveLink_get_version_info(self)

    __swig_destroy__ = _IMP_rmf.delete_HierarchySaveLink
    __del__ = lambda self : None;
    def set_save_forces(self, *args):
        """set_save_forces(HierarchySaveLink self, bool tf)"""
        return _IMP_rmf.HierarchySaveLink_set_save_forces(self, *args)

    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 get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_rmf.get_module_version()

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

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

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