python-openturns 1.2-2 / usr / share / pyshared / openturns / common.py

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


"""
Utility classes.
"""


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('_common', [dirname(__file__)])
        except ImportError:
            import _common
            return _common
        if fp is not None:
            try:
                _mod = imp.load_module('_common', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _common = swig_import_helper()
    del swig_import_helper
else:
    import _common
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


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

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _common.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _common.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _common.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _common.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _common.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _common.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _common.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _common.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _common.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _common.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _common.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _common.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _common.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _common.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _common.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _common.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

GCC_VERSION = _common.GCC_VERSION
class TestFailed:
  """
  TestFailed is used to raise an uniform exception in tests
  """
  __type = "TestFailed"
  def __init__(self,reason=""):
    self.reason = reason
  def type(self):
    return TestFailed.__type
  def what(self):
    return self.reason
  def __str__(self):
    return TestFailed.__type + ": " + self.reason
  def __lshift__(self,ch):
    self.reason += ch
    return self


def GetMemoryUsage():
  """GetMemoryUsage() -> size_t"""
  return _common.GetMemoryUsage()

def GetFullMemoryUsage():
  """GetFullMemoryUsage() -> size_t"""
  return _common.GetFullMemoryUsage()

def GetMaxMemoryUsage():
  """GetMaxMemoryUsage() -> size_t"""
  return _common.GetMaxMemoryUsage()

def GetMaxFullMemoryUsage():
  """GetMaxFullMemoryUsage() -> size_t"""
  return _common.GetMaxFullMemoryUsage()

def printMemoryUsage():
  """printMemoryUsage()"""
  return _common.printMemoryUsage()

def printMemorySpectrum():
  """printMemorySpectrum()"""
  return _common.printMemorySpectrum()

def SetMemoryFlag(*args):
  """SetMemoryFlag(bool arg1)"""
  return _common.SetMemoryFlag(*args)
class Object(_object):
    """Proxy of C++ OT::Object class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.Object_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Object self) -> OT::String"""
        return _common.Object_getClassName(self)

    __swig_destroy__ = _common.delete_Object
    __del__ = lambda self : None;
    def __repr__(self):
        """__repr__(Object self) -> OT::String"""
        return _common.Object___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Object self, OT::String const & offset="") -> OT::String
        __str__(Object self) -> OT::String
        """
        return _common.Object___str__(self, offset)

Object_swigregister = _common.Object_swigregister
Object_swigregister(Object)

def Object_GetClassName():
  """Object_GetClassName() -> OT::String"""
  return _common.Object_GetClassName()

import os

def Object___getstate__(self):

    state = dict()
    study = Study()
    filename = Path.BuildTemporaryFileName('xmlfileXXXXXX')
    
    # assume xml support
    # should use BinaryStorageManager
    with open(filename, 'rb+') as infile:
        study.setStorageManager(XMLStorageManager(filename)) 
        study.add('instance', self)
        study.save()
        infile.seek(0)
        state['xmldata'] = infile.read()
        
    os.remove(filename)
    return state

Object.__getstate__ = Object___getstate__

def Object___setstate__(self, state):

    # call ctor to initialize underlying cxx obj
    # as it is instanciated from object.__new__
    self.__init__()
    
    study = Study()
    filename = Path.BuildTemporaryFileName('xmlfileXXXXXX')
    with open(filename, 'rb+') as outfile:
        outfile.write(state['xmldata'])
        outfile.seek(0)
        study.setStorageManager(XMLStorageManager(filename)) 
        study.load()
        
    study.fillObject('instance', self)
    os.remove(filename)
    
Object.__setstate__ = Object___setstate__

class PersistentObject(Object):
    """Proxy of C++ OT::PersistentObject class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PersistentObject, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PersistentObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.PersistentObject_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PersistentObject self) -> OT::String"""
        return _common.PersistentObject_getClassName(self)

    __swig_destroy__ = _common.delete_PersistentObject
    __del__ = lambda self : None;
    def __eq__(self, *args):
        """__eq__(PersistentObject self, PersistentObject other) -> OT::Bool"""
        return _common.PersistentObject___eq__(self, *args)

    def Is(self, *args):
        """Is(PersistentObject self, PersistentObject other) -> OT::Bool"""
        return _common.PersistentObject_Is(self, *args)

    def __repr__(self):
        """__repr__(PersistentObject self) -> OT::String"""
        return _common.PersistentObject___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PersistentObject self, OT::String const & offset="") -> OT::String
        __str__(PersistentObject self) -> OT::String
        """
        return _common.PersistentObject___str__(self, offset)

    def getId(self):
        """getId(PersistentObject self) -> OT::Id"""
        return _common.PersistentObject_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(PersistentObject self, OT::Id id)"""
        return _common.PersistentObject_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(PersistentObject self) -> OT::Id"""
        return _common.PersistentObject_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(PersistentObject self, OT::Bool visible)"""
        return _common.PersistentObject_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(PersistentObject self) -> OT::Bool"""
        return _common.PersistentObject_getVisibility(self)

    def hasName(self):
        """hasName(PersistentObject self) -> OT::Bool"""
        return _common.PersistentObject_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(PersistentObject self) -> OT::Bool"""
        return _common.PersistentObject_hasVisibleName(self)

    def getName(self):
        """getName(PersistentObject self) -> OT::String"""
        return _common.PersistentObject_getName(self)

    def setName(self, *args):
        """setName(PersistentObject self, OT::String const & name)"""
        return _common.PersistentObject_setName(self, *args)

PersistentObject_swigregister = _common.PersistentObject_swigregister
PersistentObject_swigregister(PersistentObject)
cvar = _common.cvar
DefaultName = cvar.DefaultName

def PersistentObject_GetClassName():
  """PersistentObject_GetClassName() -> OT::String"""
  return _common.PersistentObject_GetClassName()

class dynamic_cast_tag(_object):
    """Proxy of C++ OT::dynamic_cast_tag class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, dynamic_cast_tag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, dynamic_cast_tag, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::dynamic_cast_tag self) -> dynamic_cast_tag"""
        this = _common.new_dynamic_cast_tag()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_dynamic_cast_tag
    __del__ = lambda self : None;
dynamic_cast_tag_swigregister = _common.dynamic_cast_tag_swigregister
dynamic_cast_tag_swigregister(dynamic_cast_tag)

class InterfaceObject(Object):
    """Proxy of C++ OT::InterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InterfaceObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.InterfaceObject_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InterfaceObject self) -> OT::String"""
        return _common.InterfaceObject_getClassName(self)

    def __repr__(self):
        """__repr__(InterfaceObject self) -> OT::String"""
        return _common.InterfaceObject___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(InterfaceObject self, OT::String const & offset="") -> OT::String
        __str__(InterfaceObject self) -> OT::String
        """
        return _common.InterfaceObject___str__(self, offset)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(InterfaceObject self) -> PersistentObjectPointer"""
        return _common.InterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(InterfaceObject self, PersistentObjectPointer obj)"""
        return _common.InterfaceObject_setImplementationAsPersistentObject(self, *args)

    def getId(self):
        """getId(InterfaceObject self) -> OT::Id"""
        return _common.InterfaceObject_getId(self)

    def setName(self, *args):
        """setName(InterfaceObject self, OT::String const & name)"""
        return _common.InterfaceObject_setName(self, *args)

    def getName(self):
        """getName(InterfaceObject self) -> OT::String"""
        return _common.InterfaceObject_getName(self)

    __swig_destroy__ = _common.delete_InterfaceObject
    __del__ = lambda self : None;
InterfaceObject_swigregister = _common.InterfaceObject_swigregister
InterfaceObject_swigregister(InterfaceObject)

def InterfaceObject_GetClassName():
  """InterfaceObject_GetClassName() -> OT::String"""
  return _common.InterfaceObject_GetClassName()

class Study(Object):
    """Proxy of C++ OT::Study class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Study, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Study, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.Study_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Study self) -> OT::String"""
        return _common.Study_getClassName(self)

    def __repr__(self):
        """__repr__(Study self) -> OT::String"""
        return _common.Study___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Study self, OT::String const & offset="") -> OT::String
        __str__(Study self) -> OT::String
        """
        return _common.Study___str__(self, offset)

    def save(self):
        """save(Study self)"""
        return _common.Study_save(self)

    def load(self):
        """load(Study self)"""
        return _common.Study_load(self)

    def setStorageManager(self, *args):
        """setStorageManager(Study self, StorageManager smgr)"""
        return _common.Study_setStorageManager(self, *args)

    def getStorageManager(self):
        """getStorageManager(Study self) -> StorageManagerPointer"""
        return _common.Study_getStorageManager(self)

    def add(self, *args):
        """
        add(Study self, InterfaceObject io)
        add(Study self, OT::String const & label, InterfaceObject io, OT::Bool force=False)
        add(Study self, OT::String const & label, InterfaceObject io)
        add(Study self, PersistentObject po)
        add(Study self, OT::String const & label, PersistentObject po, OT::Bool force=False)
        add(Study self, OT::String const & label, PersistentObject po)
        """
        return _common.Study_add(self, *args)

    def remove(self, *args):
        """
        remove(Study self, InterfaceObject io)
        remove(Study self, OT::String const & label)
        """
        return _common.Study_remove(self, *args)

    def hasObject(self, *args):
        """
        hasObject(Study self, OT::Id id) -> OT::Bool
        hasObject(Study self, OT::String const & label) -> OT::Bool
        """
        return _common.Study_hasObject(self, *args)

    def getObject(self, *args):
        """
        getObject(Study self, OT::Id id) -> PersistentObjectPointer
        getObject(Study self, OT::String const & label) -> PersistentObjectPointer
        """
        return _common.Study_getObject(self, *args)

    def fillObjectByName(self, *args):
        """
        fillObjectByName(Study self, PersistentObject po, OT::String const & name)
        fillObjectByName(Study self, InterfaceObject io, OT::String const & name)
        """
        return _common.Study_fillObjectByName(self, *args)

    def fillObject(self, *args):
        """
        fillObject(Study self, OT::Id id, PersistentObject po)
        fillObject(Study self, OT::Id id, InterfaceObject io)
        fillObject(Study self, OT::String const & name, PersistentObject po)
        fillObject(Study self, OT::String const & name, InterfaceObject io)
        """
        return _common.Study_fillObject(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Study self) -> Study
        __init__(OT::Study self, Study other) -> Study
        """
        this = _common.new_Study(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_Study
    __del__ = lambda self : None;
Study_swigregister = _common.Study_swigregister
Study_swigregister(Study)

def Study_GetClassName():
  """Study_GetClassName() -> OT::String"""
  return _common.Study_GetClassName()

class SaveAction(_object):
    """Proxy of C++ OT::SaveAction class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SaveAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SaveAction, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::SaveAction self) -> SaveAction"""
        this = _common.new_SaveAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_SaveAction
    __del__ = lambda self : None;
SaveAction_swigregister = _common.SaveAction_swigregister
SaveAction_swigregister(SaveAction)

class LoadAction(_object):
    """Proxy of C++ OT::LoadAction class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LoadAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LoadAction, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::LoadAction self) -> LoadAction"""
        this = _common.new_LoadAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_LoadAction
    __del__ = lambda self : None;
LoadAction_swigregister = _common.LoadAction_swigregister
LoadAction_swigregister(LoadAction)

class StorageManager(Object):
    """Proxy of C++ OT::StorageManager class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StorageManager, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StorageManager, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.StorageManager_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StorageManager self) -> OT::String"""
        return _common.StorageManager_getClassName(self)

    def __init__(self, defaultVersion=1): 
        """
        __init__(OT::StorageManager self, OT::UnsignedLong defaultVersion=1) -> StorageManager
        __init__(OT::StorageManager self) -> StorageManager
        """
        this = _common.new_StorageManager(defaultVersion)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(StorageManager self) -> OT::String"""
        return _common.StorageManager___repr__(self)

    def save(self, *args):
        """
        save(StorageManager self, PersistentObject obj, OT::String const & label, bool fromStudy=False)
        save(StorageManager self, PersistentObject obj, OT::String const & label)
        """
        return _common.StorageManager_save(self, *args)

    def load(self, *args):
        """load(StorageManager self, Study study)"""
        return _common.StorageManager_load(self, *args)

    def getStudy(self):
        """getStudy(StorageManager self) -> Study"""
        return _common.StorageManager_getStudy(self)

    def setStudy(self, *args):
        """setStudy(StorageManager self, Study p_study)"""
        return _common.StorageManager_setStudy(self, *args)

    def getDefaultStudyVersion(self):
        """getDefaultStudyVersion(StorageManager self) -> OT::UnsignedLong"""
        return _common.StorageManager_getDefaultStudyVersion(self)

    def getStudyVersion(self):
        """getStudyVersion(StorageManager self) -> OT::UnsignedLong"""
        return _common.StorageManager_getStudyVersion(self)

    def setStudyVersion(self, *args):
        """setStudyVersion(StorageManager self, OT::UnsignedLong version)"""
        return _common.StorageManager_setStudyVersion(self, *args)

    def initialize(self, *args):
        """
        initialize(StorageManager self, SaveAction caller)
        initialize(StorageManager self, LoadAction caller)
        """
        return _common.StorageManager_initialize(self, *args)

    def finalize(self, *args):
        """
        finalize(StorageManager self, SaveAction caller)
        finalize(StorageManager self, LoadAction caller)
        """
        return _common.StorageManager_finalize(self, *args)

    def read(self):
        """read(StorageManager self)"""
        return _common.StorageManager_read(self)

    def write(self):
        """write(StorageManager self)"""
        return _common.StorageManager_write(self)

    def isSavedObject(self, *args):
        """isSavedObject(StorageManager self, OT::Id id) -> OT::Bool"""
        return _common.StorageManager_isSavedObject(self, *args)

    def markObjectAsSaved(self, *args):
        """markObjectAsSaved(StorageManager self, OT::Id id)"""
        return _common.StorageManager_markObjectAsSaved(self, *args)

    __swig_destroy__ = _common.delete_StorageManager
    __del__ = lambda self : None;
StorageManager_swigregister = _common.StorageManager_swigregister
StorageManager_swigregister(StorageManager)

def StorageManager_GetClassName():
  """StorageManager_GetClassName() -> OT::String"""
  return _common.StorageManager_GetClassName()

class VersionList(_object):
    """Proxy of C++ OT::VersionList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VersionList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VersionList, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::VersionList self) -> VersionList"""
        this = _common.new_VersionList()
        try: self.this.append(this)
        except: self.this = this
    def contains(self, *args):
        """contains(VersionList self, OT::UnsignedLong v) -> OT::Bool"""
        return _common.VersionList_contains(self, *args)

    __swig_destroy__ = _common.delete_VersionList
    __del__ = lambda self : None;
VersionList_swigregister = _common.VersionList_swigregister
VersionList_swigregister(VersionList)

class XMLStorageManager(StorageManager):
    """Proxy of C++ OT::XMLStorageManager class"""
    __swig_setmethods__ = {}
    for _s in [StorageManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLStorageManager, name, value)
    __swig_getmethods__ = {}
    for _s in [StorageManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XMLStorageManager, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.XMLStorageManager_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(XMLStorageManager self) -> OT::String"""
        return _common.XMLStorageManager_getClassName(self)

    def __init__(self, *args): 
        """__init__(OT::XMLStorageManager self, OT::FileName const & filename) -> XMLStorageManager"""
        this = _common.new_XMLStorageManager(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(XMLStorageManager self) -> OT::String"""
        return _common.XMLStorageManager___repr__(self)

    def getFileName(self):
        """getFileName(XMLStorageManager self) -> OT::String"""
        return _common.XMLStorageManager_getFileName(self)

    def setFileName(self, *args):
        """setFileName(XMLStorageManager self, OT::String const & fileName)"""
        return _common.XMLStorageManager_setFileName(self, *args)

    def save(self, *args):
        """
        save(XMLStorageManager self, PersistentObject obj, OT::String const & label, bool fromStudy=False)
        save(XMLStorageManager self, PersistentObject obj, OT::String const & label)
        """
        return _common.XMLStorageManager_save(self, *args)

    def load(self, *args):
        """load(XMLStorageManager self, Study study)"""
        return _common.XMLStorageManager_load(self, *args)

    def initialize(self, *args):
        """
        initialize(XMLStorageManager self, SaveAction caller)
        initialize(XMLStorageManager self, LoadAction caller)
        """
        return _common.XMLStorageManager_initialize(self, *args)

    def finalize(self, *args):
        """
        finalize(XMLStorageManager self, SaveAction caller)
        finalize(XMLStorageManager self, LoadAction caller)
        """
        return _common.XMLStorageManager_finalize(self, *args)

    def read(self):
        """read(XMLStorageManager self)"""
        return _common.XMLStorageManager_read(self)

    def write(self):
        """write(XMLStorageManager self)"""
        return _common.XMLStorageManager_write(self)

    __swig_destroy__ = _common.delete_XMLStorageManager
    __del__ = lambda self : None;
XMLStorageManager_swigregister = _common.XMLStorageManager_swigregister
XMLStorageManager_swigregister(XMLStorageManager)

def XMLStorageManager_GetClassName():
  """XMLStorageManager_GetClassName() -> OT::String"""
  return _common.XMLStorageManager_GetClassName()
XMLStorageManager.SupportedVersions = _common.cvar.XMLStorageManager_SupportedVersions
XMLStorageManager.Precision_ = _common.cvar.XMLStorageManager_Precision_

class TTY(_object):
    """Proxy of C++ OT::TTY class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TTY, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TTY, name)
    __repr__ = _swig_repr
    DEFAULT = _common.TTY_DEFAULT
    BOLD = _common.TTY_BOLD
    UNDERLINE = _common.TTY_UNDERLINE
    BLINK = _common.TTY_BLINK
    BLACKFG = _common.TTY_BLACKFG
    REDFG = _common.TTY_REDFG
    GREENFG = _common.TTY_GREENFG
    YELLOWFG = _common.TTY_YELLOWFG
    BLUEFG = _common.TTY_BLUEFG
    PURPLEFG = _common.TTY_PURPLEFG
    CYANFG = _common.TTY_CYANFG
    WHITEFG = _common.TTY_WHITEFG
    BLACKBG = _common.TTY_BLACKBG
    REDBG = _common.TTY_REDBG
    GREENBG = _common.TTY_GREENBG
    YELLOWBG = _common.TTY_YELLOWBG
    BLUEBG = _common.TTY_BLUEBG
    PURPLEBG = _common.TTY_PURPLEBG
    CYANBG = _common.TTY_CYANBG
    WHITEBG = _common.TTY_WHITEBG
    LASTCOLOR = _common.TTY_LASTCOLOR
    def GetColor(*args):
        """GetColor(OT::TTY::Color c) -> char const *"""
        return _common.TTY_GetColor(*args)

    if _newclass:GetColor = staticmethod(GetColor)
    __swig_getmethods__["GetColor"] = lambda x: GetColor
    def ShowColors(*args):
        """ShowColors(OT::Bool flag)"""
        return _common.TTY_ShowColors(*args)

    if _newclass:ShowColors = staticmethod(ShowColors)
    __swig_getmethods__["ShowColors"] = lambda x: ShowColors
    def ColoredOutput():
        """ColoredOutput() -> OT::Bool"""
        return _common.TTY_ColoredOutput()

    if _newclass:ColoredOutput = staticmethod(ColoredOutput)
    __swig_getmethods__["ColoredOutput"] = lambda x: ColoredOutput
    def __init__(self): 
        """__init__(OT::TTY self) -> TTY"""
        this = _common.new_TTY()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_TTY
    __del__ = lambda self : None;
TTY_swigregister = _common.TTY_swigregister
TTY_swigregister(TTY)

def TTY_GetColor(*args):
  """TTY_GetColor(OT::TTY::Color c) -> char const *"""
  return _common.TTY_GetColor(*args)

def TTY_ShowColors(*args):
  """TTY_ShowColors(OT::Bool flag)"""
  return _common.TTY_ShowColors(*args)

def TTY_ColoredOutput():
  """TTY_ColoredOutput() -> OT::Bool"""
  return _common.TTY_ColoredOutput()

class Log(_object):
    """Proxy of C++ OT::Log class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Log, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Log, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def Debug(*args):
        """Debug(OT::String const & msg)"""
        return _common.Log_Debug(*args)

    if _newclass:Debug = staticmethod(Debug)
    __swig_getmethods__["Debug"] = lambda x: Debug
    def HasDebug():
        """HasDebug() -> OT::Bool"""
        return _common.Log_HasDebug()

    if _newclass:HasDebug = staticmethod(HasDebug)
    __swig_getmethods__["HasDebug"] = lambda x: HasDebug
    def Wrapper(*args):
        """Wrapper(OT::String const & msg)"""
        return _common.Log_Wrapper(*args)

    if _newclass:Wrapper = staticmethod(Wrapper)
    __swig_getmethods__["Wrapper"] = lambda x: Wrapper
    def HasWrapper():
        """HasWrapper() -> OT::Bool"""
        return _common.Log_HasWrapper()

    if _newclass:HasWrapper = staticmethod(HasWrapper)
    __swig_getmethods__["HasWrapper"] = lambda x: HasWrapper
    def Info(*args):
        """Info(OT::String const & msg)"""
        return _common.Log_Info(*args)

    if _newclass:Info = staticmethod(Info)
    __swig_getmethods__["Info"] = lambda x: Info
    def HasInfo():
        """HasInfo() -> OT::Bool"""
        return _common.Log_HasInfo()

    if _newclass:HasInfo = staticmethod(HasInfo)
    __swig_getmethods__["HasInfo"] = lambda x: HasInfo
    def User(*args):
        """User(OT::String const & msg)"""
        return _common.Log_User(*args)

    if _newclass:User = staticmethod(User)
    __swig_getmethods__["User"] = lambda x: User
    def HasUser():
        """HasUser() -> OT::Bool"""
        return _common.Log_HasUser()

    if _newclass:HasUser = staticmethod(HasUser)
    __swig_getmethods__["HasUser"] = lambda x: HasUser
    def Warn(*args):
        """Warn(OT::String const & msg)"""
        return _common.Log_Warn(*args)

    if _newclass:Warn = staticmethod(Warn)
    __swig_getmethods__["Warn"] = lambda x: Warn
    def HasWarn():
        """HasWarn() -> OT::Bool"""
        return _common.Log_HasWarn()

    if _newclass:HasWarn = staticmethod(HasWarn)
    __swig_getmethods__["HasWarn"] = lambda x: HasWarn
    def Error(*args):
        """Error(OT::String const & msg)"""
        return _common.Log_Error(*args)

    if _newclass:Error = staticmethod(Error)
    __swig_getmethods__["Error"] = lambda x: Error
    def HasError():
        """HasError() -> OT::Bool"""
        return _common.Log_HasError()

    if _newclass:HasError = staticmethod(HasError)
    __swig_getmethods__["HasError"] = lambda x: HasError
    def Trace(*args):
        """Trace(OT::String const & msg)"""
        return _common.Log_Trace(*args)

    if _newclass:Trace = staticmethod(Trace)
    __swig_getmethods__["Trace"] = lambda x: Trace
    def HasTrace():
        """HasTrace() -> OT::Bool"""
        return _common.Log_HasTrace()

    if _newclass:HasTrace = staticmethod(HasTrace)
    __swig_getmethods__["HasTrace"] = lambda x: HasTrace
    def SetFile(*args):
        """SetFile(OT::FileName const & file)"""
        return _common.Log_SetFile(*args)

    if _newclass:SetFile = staticmethod(SetFile)
    __swig_getmethods__["SetFile"] = lambda x: SetFile
    def Show(*args):
        """Show(OT::Log::Severity flags)"""
        return _common.Log_Show(*args)

    if _newclass:Show = staticmethod(Show)
    __swig_getmethods__["Show"] = lambda x: Show
    def Flags():
        """Flags() -> OT::Log::Severity"""
        return _common.Log_Flags()

    if _newclass:Flags = staticmethod(Flags)
    __swig_getmethods__["Flags"] = lambda x: Flags
    def Flush():
        """Flush()"""
        return _common.Log_Flush()

    if _newclass:Flush = staticmethod(Flush)
    __swig_getmethods__["Flush"] = lambda x: Flush
    def Repeat(*args):
        """Repeat(OT::Bool repeat)"""
        return _common.Log_Repeat(*args)

    if _newclass:Repeat = staticmethod(Repeat)
    __swig_getmethods__["Repeat"] = lambda x: Repeat
    def SetColor(*args):
        """
        SetColor(OT::Log::Severity const severity, OT::TTY::Color const color)
        SetColor(OT::Log::Severity const severity, OT::String const & color)
        """
        return _common.Log_SetColor(*args)

    if _newclass:SetColor = staticmethod(SetColor)
    __swig_getmethods__["SetColor"] = lambda x: SetColor
    def GetColor(*args):
        """GetColor(OT::Log::Severity const severity) -> OT::String"""
        return _common.Log_GetColor(*args)

    if _newclass:GetColor = staticmethod(GetColor)
    __swig_getmethods__["GetColor"] = lambda x: GetColor
    __swig_destroy__ = _common.delete_Log
    __del__ = lambda self : None;
Log_swigregister = _common.Log_swigregister
Log_swigregister(Log)
Log.DBG = _common.cvar.Log_DBG
Log.WRAPPER = _common.cvar.Log_WRAPPER
Log.INFO = _common.cvar.Log_INFO
Log.USER = _common.cvar.Log_USER
Log.WARN = _common.cvar.Log_WARN
Log.ERROR = _common.cvar.Log_ERROR
Log.TRACE = _common.cvar.Log_TRACE
Log.DEFAULT = _common.cvar.Log_DEFAULT
Log.NONE = _common.cvar.Log_NONE
Log.ALL = _common.cvar.Log_ALL

def Log_Debug(*args):
  """Log_Debug(OT::String const & msg)"""
  return _common.Log_Debug(*args)

def Log_HasDebug():
  """Log_HasDebug() -> OT::Bool"""
  return _common.Log_HasDebug()

def Log_Wrapper(*args):
  """Log_Wrapper(OT::String const & msg)"""
  return _common.Log_Wrapper(*args)

def Log_HasWrapper():
  """Log_HasWrapper() -> OT::Bool"""
  return _common.Log_HasWrapper()

def Log_Info(*args):
  """Log_Info(OT::String const & msg)"""
  return _common.Log_Info(*args)

def Log_HasInfo():
  """Log_HasInfo() -> OT::Bool"""
  return _common.Log_HasInfo()

def Log_User(*args):
  """Log_User(OT::String const & msg)"""
  return _common.Log_User(*args)

def Log_HasUser():
  """Log_HasUser() -> OT::Bool"""
  return _common.Log_HasUser()

def Log_Warn(*args):
  """Log_Warn(OT::String const & msg)"""
  return _common.Log_Warn(*args)

def Log_HasWarn():
  """Log_HasWarn() -> OT::Bool"""
  return _common.Log_HasWarn()

def Log_Error(*args):
  """Log_Error(OT::String const & msg)"""
  return _common.Log_Error(*args)

def Log_HasError():
  """Log_HasError() -> OT::Bool"""
  return _common.Log_HasError()

def Log_Trace(*args):
  """Log_Trace(OT::String const & msg)"""
  return _common.Log_Trace(*args)

def Log_HasTrace():
  """Log_HasTrace() -> OT::Bool"""
  return _common.Log_HasTrace()

def Log_SetFile(*args):
  """Log_SetFile(OT::FileName const & file)"""
  return _common.Log_SetFile(*args)

def Log_Show(*args):
  """Log_Show(OT::Log::Severity flags)"""
  return _common.Log_Show(*args)

def Log_Flags():
  """Log_Flags() -> OT::Log::Severity"""
  return _common.Log_Flags()

def Log_Flush():
  """Log_Flush()"""
  return _common.Log_Flush()

def Log_Repeat(*args):
  """Log_Repeat(OT::Bool repeat)"""
  return _common.Log_Repeat(*args)

def Log_SetColor(*args):
  """
    SetColor(OT::Log::Severity const severity, OT::TTY::Color const color)
    Log_SetColor(OT::Log::Severity const severity, OT::String const & color)
    """
  return _common.Log_SetColor(*args)

def Log_GetColor(*args):
  """Log_GetColor(OT::Log::Severity const severity) -> OT::String"""
  return _common.Log_GetColor(*args)

class Log_init(_object):
    """Proxy of C++ OT::Log_init class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Log_init, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Log_init, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::Log_init self) -> Log_init"""
        this = _common.new_Log_init()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_Log_init
    __del__ = lambda self : None;
Log_init_swigregister = _common.Log_init_swigregister
Log_init_swigregister(Log_init)

class DirectoryList(_object):
    """Proxy of C++ std::vector<(OT::FileName)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirectoryList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DirectoryList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(DirectoryList self) -> SwigPyIterator"""
        return _common.DirectoryList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(DirectoryList self) -> bool"""
        return _common.DirectoryList___nonzero__(self)

    def __bool__(self):
        """__bool__(DirectoryList self) -> bool"""
        return _common.DirectoryList___bool__(self)

    def __len__(self):
        """__len__(DirectoryList self) -> std::vector< std::string >::size_type"""
        return _common.DirectoryList___len__(self)

    def pop(self):
        """pop(DirectoryList self) -> std::vector< std::string >::value_type"""
        return _common.DirectoryList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(DirectoryList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> DirectoryList"""
        return _common.DirectoryList___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(DirectoryList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, 
            DirectoryList v=std::vector< std::string,std::allocator< std::string > >())
        __setslice__(DirectoryList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        """
        return _common.DirectoryList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(DirectoryList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _common.DirectoryList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(DirectoryList self, std::vector< std::string >::difference_type i)
        __delitem__(DirectoryList self, PySliceObject * slice)
        """
        return _common.DirectoryList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(DirectoryList self, PySliceObject * slice) -> DirectoryList
        __getitem__(DirectoryList self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _common.DirectoryList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(DirectoryList self, PySliceObject * slice, DirectoryList v)
        __setitem__(DirectoryList self, PySliceObject * slice)
        __setitem__(DirectoryList self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _common.DirectoryList___setitem__(self, *args)

    def append(self, *args):
        """append(DirectoryList self, std::vector< std::string >::value_type const & x)"""
        return _common.DirectoryList_append(self, *args)

    def empty(self):
        """empty(DirectoryList self) -> bool"""
        return _common.DirectoryList_empty(self)

    def size(self):
        """size(DirectoryList self) -> std::vector< std::string >::size_type"""
        return _common.DirectoryList_size(self)

    def clear(self):
        """clear(DirectoryList self)"""
        return _common.DirectoryList_clear(self)

    def swap(self, *args):
        """swap(DirectoryList self, DirectoryList v)"""
        return _common.DirectoryList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(DirectoryList self) -> std::vector< std::string >::allocator_type"""
        return _common.DirectoryList_get_allocator(self)

    def begin(self):
        """begin(DirectoryList self) -> std::vector< std::string >::iterator"""
        return _common.DirectoryList_begin(self)

    def end(self):
        """end(DirectoryList self) -> std::vector< std::string >::iterator"""
        return _common.DirectoryList_end(self)

    def rbegin(self):
        """rbegin(DirectoryList self) -> std::vector< std::string >::reverse_iterator"""
        return _common.DirectoryList_rbegin(self)

    def rend(self):
        """rend(DirectoryList self) -> std::vector< std::string >::reverse_iterator"""
        return _common.DirectoryList_rend(self)

    def pop_back(self):
        """pop_back(DirectoryList self)"""
        return _common.DirectoryList_pop_back(self)

    def erase(self, *args):
        """
        erase(DirectoryList self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(DirectoryList self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _common.DirectoryList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(OT::FileName)> self) -> DirectoryList
        __init__(std::vector<(OT::FileName)> self, DirectoryList arg2) -> DirectoryList
        __init__(std::vector<(OT::FileName)> self, std::vector< std::string >::size_type size) -> DirectoryList
        __init__(std::vector<(OT::FileName)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> DirectoryList
        """
        this = _common.new_DirectoryList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(DirectoryList self, std::vector< std::string >::value_type const & x)"""
        return _common.DirectoryList_push_back(self, *args)

    def front(self):
        """front(DirectoryList self) -> std::vector< std::string >::value_type const &"""
        return _common.DirectoryList_front(self)

    def back(self):
        """back(DirectoryList self) -> std::vector< std::string >::value_type const &"""
        return _common.DirectoryList_back(self)

    def assign(self, *args):
        """assign(DirectoryList self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _common.DirectoryList_assign(self, *args)

    def resize(self, *args):
        """
        resize(DirectoryList self, std::vector< std::string >::size_type new_size)
        resize(DirectoryList self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _common.DirectoryList_resize(self, *args)

    def insert(self, *args):
        """
        insert(DirectoryList self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(DirectoryList self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, 
            std::vector< std::string >::value_type const & x)
        """
        return _common.DirectoryList_insert(self, *args)

    def reserve(self, *args):
        """reserve(DirectoryList self, std::vector< std::string >::size_type n)"""
        return _common.DirectoryList_reserve(self, *args)

    def capacity(self):
        """capacity(DirectoryList self) -> std::vector< std::string >::size_type"""
        return _common.DirectoryList_capacity(self)

    __swig_destroy__ = _common.delete_DirectoryList
    __del__ = lambda self : None;
DirectoryList_swigregister = _common.DirectoryList_swigregister
DirectoryList_swigregister(DirectoryList)

class Path(_object):
    """Proxy of C++ OT::Path class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Path, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Path, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def GetInstallationDirectory():
        """GetInstallationDirectory() -> OT::FileName"""
        return _common.Path_GetInstallationDirectory()

    if _newclass:GetInstallationDirectory = staticmethod(GetInstallationDirectory)
    __swig_getmethods__["GetInstallationDirectory"] = lambda x: GetInstallationDirectory
    def GetModuleDirectory():
        """GetModuleDirectory() -> OT::FileName"""
        return _common.Path_GetModuleDirectory()

    if _newclass:GetModuleDirectory = staticmethod(GetModuleDirectory)
    __swig_getmethods__["GetModuleDirectory"] = lambda x: GetModuleDirectory
    def GetStandardWrapperDirectory():
        """GetStandardWrapperDirectory() -> OT::FileName"""
        return _common.Path_GetStandardWrapperDirectory()

    if _newclass:GetStandardWrapperDirectory = staticmethod(GetStandardWrapperDirectory)
    __swig_getmethods__["GetStandardWrapperDirectory"] = lambda x: GetStandardWrapperDirectory
    def GetWrapperDirectoryList():
        """GetWrapperDirectoryList() -> DirectoryList"""
        return _common.Path_GetWrapperDirectoryList()

    if _newclass:GetWrapperDirectoryList = staticmethod(GetWrapperDirectoryList)
    __swig_getmethods__["GetWrapperDirectoryList"] = lambda x: GetWrapperDirectoryList
    def GetConfigDirectoryList():
        """GetConfigDirectoryList() -> DirectoryList"""
        return _common.Path_GetConfigDirectoryList()

    if _newclass:GetConfigDirectoryList = staticmethod(GetConfigDirectoryList)
    __swig_getmethods__["GetConfigDirectoryList"] = lambda x: GetConfigDirectoryList
    def FindFileByNameInDirectoryList(*args):
        """FindFileByNameInDirectoryList(OT::FileName const & name, DirectoryList dirList) -> OT::FileName"""
        return _common.Path_FindFileByNameInDirectoryList(*args)

    if _newclass:FindFileByNameInDirectoryList = staticmethod(FindFileByNameInDirectoryList)
    __swig_getmethods__["FindFileByNameInDirectoryList"] = lambda x: FindFileByNameInDirectoryList
    def GetTemporaryDirectory():
        """GetTemporaryDirectory() -> OT::FileName"""
        return _common.Path_GetTemporaryDirectory()

    if _newclass:GetTemporaryDirectory = staticmethod(GetTemporaryDirectory)
    __swig_getmethods__["GetTemporaryDirectory"] = lambda x: GetTemporaryDirectory
    def BuildTemporaryFileName(*args):
        """BuildTemporaryFileName(OT::FileName const & pattern) -> OT::FileName"""
        return _common.Path_BuildTemporaryFileName(*args)

    if _newclass:BuildTemporaryFileName = staticmethod(BuildTemporaryFileName)
    __swig_getmethods__["BuildTemporaryFileName"] = lambda x: BuildTemporaryFileName
    def CreateTemporaryDirectory(*args):
        """CreateTemporaryDirectory(OT::FileName const & directoryPrefix) -> OT::FileName"""
        return _common.Path_CreateTemporaryDirectory(*args)

    if _newclass:CreateTemporaryDirectory = staticmethod(CreateTemporaryDirectory)
    __swig_getmethods__["CreateTemporaryDirectory"] = lambda x: CreateTemporaryDirectory
    def DeleteTemporaryDirectory(*args):
        """DeleteTemporaryDirectory(OT::FileName const & directoryName)"""
        return _common.Path_DeleteTemporaryDirectory(*args)

    if _newclass:DeleteTemporaryDirectory = staticmethod(DeleteTemporaryDirectory)
    __swig_getmethods__["DeleteTemporaryDirectory"] = lambda x: DeleteTemporaryDirectory
    __swig_destroy__ = _common.delete_Path
    __del__ = lambda self : None;
Path_swigregister = _common.Path_swigregister
Path_swigregister(Path)

def Path_GetInstallationDirectory():
  """Path_GetInstallationDirectory() -> OT::FileName"""
  return _common.Path_GetInstallationDirectory()

def Path_GetModuleDirectory():
  """Path_GetModuleDirectory() -> OT::FileName"""
  return _common.Path_GetModuleDirectory()

def Path_GetStandardWrapperDirectory():
  """Path_GetStandardWrapperDirectory() -> OT::FileName"""
  return _common.Path_GetStandardWrapperDirectory()

def Path_GetWrapperDirectoryList():
  """Path_GetWrapperDirectoryList() -> DirectoryList"""
  return _common.Path_GetWrapperDirectoryList()

def Path_GetConfigDirectoryList():
  """Path_GetConfigDirectoryList() -> DirectoryList"""
  return _common.Path_GetConfigDirectoryList()

def Path_FindFileByNameInDirectoryList(*args):
  """Path_FindFileByNameInDirectoryList(OT::FileName const & name, DirectoryList dirList) -> OT::FileName"""
  return _common.Path_FindFileByNameInDirectoryList(*args)

def Path_GetTemporaryDirectory():
  """Path_GetTemporaryDirectory() -> OT::FileName"""
  return _common.Path_GetTemporaryDirectory()

def Path_BuildTemporaryFileName(*args):
  """Path_BuildTemporaryFileName(OT::FileName const & pattern) -> OT::FileName"""
  return _common.Path_BuildTemporaryFileName(*args)

def Path_CreateTemporaryDirectory(*args):
  """Path_CreateTemporaryDirectory(OT::FileName const & directoryPrefix) -> OT::FileName"""
  return _common.Path_CreateTemporaryDirectory(*args)

def Path_DeleteTemporaryDirectory(*args):
  """Path_DeleteTemporaryDirectory(OT::FileName const & directoryName)"""
  return _common.Path_DeleteTemporaryDirectory(*args)

class StringStringMap(_object):
    """Proxy of C++ std::map<(OT::String,OT::String)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringStringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringStringMap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(StringStringMap self) -> SwigPyIterator"""
        return _common.StringStringMap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(StringStringMap self) -> bool"""
        return _common.StringStringMap___nonzero__(self)

    def __bool__(self):
        """__bool__(StringStringMap self) -> bool"""
        return _common.StringStringMap___bool__(self)

    def __len__(self):
        """__len__(StringStringMap self) -> std::map< std::string,std::string >::size_type"""
        return _common.StringStringMap___len__(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args):
        """__getitem__(StringStringMap self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _common.StringStringMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(StringStringMap self, std::map< std::string,std::string >::key_type const & key)"""
        return _common.StringStringMap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(StringStringMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _common.StringStringMap_has_key(self, *args)

    def keys(self):
        """keys(StringStringMap self) -> PyObject *"""
        return _common.StringStringMap_keys(self)

    def values(self):
        """values(StringStringMap self) -> PyObject *"""
        return _common.StringStringMap_values(self)

    def items(self):
        """items(StringStringMap self) -> PyObject *"""
        return _common.StringStringMap_items(self)

    def __contains__(self, *args):
        """__contains__(StringStringMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _common.StringStringMap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(StringStringMap self) -> SwigPyIterator"""
        return _common.StringStringMap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(StringStringMap self) -> SwigPyIterator"""
        return _common.StringStringMap_value_iterator(self)

    def __setitem__(self, *args):
        """
        __setitem__(StringStringMap self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(StringStringMap self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _common.StringStringMap___setitem__(self, *args)

    def asdict(self):
        """asdict(StringStringMap self) -> PyObject *"""
        return _common.StringStringMap_asdict(self)

    def __init__(self, *args): 
        """
        __init__(std::map<(OT::String,OT::String)> self, std::less< std::string > const & arg2) -> StringStringMap
        __init__(std::map<(OT::String,OT::String)> self) -> StringStringMap
        __init__(std::map<(OT::String,OT::String)> self, StringStringMap arg2) -> StringStringMap
        """
        this = _common.new_StringStringMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(StringStringMap self) -> bool"""
        return _common.StringStringMap_empty(self)

    def size(self):
        """size(StringStringMap self) -> std::map< std::string,std::string >::size_type"""
        return _common.StringStringMap_size(self)

    def clear(self):
        """clear(StringStringMap self)"""
        return _common.StringStringMap_clear(self)

    def swap(self, *args):
        """swap(StringStringMap self, StringStringMap v)"""
        return _common.StringStringMap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(StringStringMap self) -> std::map< std::string,std::string >::allocator_type"""
        return _common.StringStringMap_get_allocator(self)

    def begin(self):
        """begin(StringStringMap self) -> std::map< std::string,std::string >::iterator"""
        return _common.StringStringMap_begin(self)

    def end(self):
        """end(StringStringMap self) -> std::map< std::string,std::string >::iterator"""
        return _common.StringStringMap_end(self)

    def rbegin(self):
        """rbegin(StringStringMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _common.StringStringMap_rbegin(self)

    def rend(self):
        """rend(StringStringMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _common.StringStringMap_rend(self)

    def count(self, *args):
        """count(StringStringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _common.StringStringMap_count(self, *args)

    def erase(self, *args):
        """
        erase(StringStringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(StringStringMap self, std::map< std::string,std::string >::iterator position)
        erase(StringStringMap self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _common.StringStringMap_erase(self, *args)

    def find(self, *args):
        """find(StringStringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _common.StringStringMap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(StringStringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _common.StringStringMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(StringStringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _common.StringStringMap_upper_bound(self, *args)

    __swig_destroy__ = _common.delete_StringStringMap
    __del__ = lambda self : None;
StringStringMap_swigregister = _common.StringStringMap_swigregister
StringStringMap_swigregister(StringStringMap)

class ResourceMapInstance(_object):
    """Proxy of C++ OT::ResourceMapInstance class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceMapInstance, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResourceMapInstance, name)
    def __init__(self, *args): 
        """
        __init__(OT::ResourceMapInstance self, ResourceMap rm) -> ResourceMapInstance
        __init__(OT::ResourceMapInstance self, ResourceMapInstance other) -> ResourceMapInstance
        """
        this = _common.new_ResourceMapInstance(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(ResourceMapInstance self) -> OT::String"""
        return _common.ResourceMapInstance___repr__(self)

    __swig_destroy__ = _common.delete_ResourceMapInstance
    __del__ = lambda self : None;
ResourceMapInstance_swigregister = _common.ResourceMapInstance_swigregister
ResourceMapInstance_swigregister(ResourceMapInstance)

class ResourceMap(_object):
    """Proxy of C++ OT::ResourceMap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResourceMap, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    def GetInstance():
        """GetInstance() -> ResourceMapInstance"""
        return _common.ResourceMap_GetInstance()

    if _newclass:GetInstance = staticmethod(GetInstance)
    __swig_getmethods__["GetInstance"] = lambda x: GetInstance
    def Release():
        """Release()"""
        return _common.ResourceMap_Release()

    if _newclass:Release = staticmethod(Release)
    __swig_getmethods__["Release"] = lambda x: Release
    def Initialize():
        """Initialize()"""
        return _common.ResourceMap_Initialize()

    if _newclass:Initialize = staticmethod(Initialize)
    __swig_getmethods__["Initialize"] = lambda x: Initialize
    def Get(*args):
        """Get(OT::String key) -> OT::String"""
        return _common.ResourceMap_Get(*args)

    if _newclass:Get = staticmethod(Get)
    __swig_getmethods__["Get"] = lambda x: Get
    def GetAsBool(*args):
        """GetAsBool(OT::String key) -> OT::Bool"""
        return _common.ResourceMap_GetAsBool(*args)

    if _newclass:GetAsBool = staticmethod(GetAsBool)
    __swig_getmethods__["GetAsBool"] = lambda x: GetAsBool
    def GetAsUnsignedLong(*args):
        """GetAsUnsignedLong(OT::String key) -> OT::UnsignedLong"""
        return _common.ResourceMap_GetAsUnsignedLong(*args)

    if _newclass:GetAsUnsignedLong = staticmethod(GetAsUnsignedLong)
    __swig_getmethods__["GetAsUnsignedLong"] = lambda x: GetAsUnsignedLong
    def GetAsNumericalScalar(*args):
        """GetAsNumericalScalar(OT::String key) -> OT::NumericalScalar"""
        return _common.ResourceMap_GetAsNumericalScalar(*args)

    if _newclass:GetAsNumericalScalar = staticmethod(GetAsNumericalScalar)
    __swig_getmethods__["GetAsNumericalScalar"] = lambda x: GetAsNumericalScalar
    def GetAsNewCharArray(*args):
        """GetAsNewCharArray(OT::String key) -> char *"""
        return _common.ResourceMap_GetAsNewCharArray(*args)

    if _newclass:GetAsNewCharArray = staticmethod(GetAsNewCharArray)
    __swig_getmethods__["GetAsNewCharArray"] = lambda x: GetAsNewCharArray
    def Set(*args):
        """Set(OT::String key, OT::String value)"""
        return _common.ResourceMap_Set(*args)

    if _newclass:Set = staticmethod(Set)
    __swig_getmethods__["Set"] = lambda x: Set
    def SetAsBool(*args):
        """SetAsBool(OT::String key, OT::Bool value)"""
        return _common.ResourceMap_SetAsBool(*args)

    if _newclass:SetAsBool = staticmethod(SetAsBool)
    __swig_getmethods__["SetAsBool"] = lambda x: SetAsBool
    def SetAsUnsignedLong(*args):
        """SetAsUnsignedLong(OT::String key, OT::UnsignedLong value)"""
        return _common.ResourceMap_SetAsUnsignedLong(*args)

    if _newclass:SetAsUnsignedLong = staticmethod(SetAsUnsignedLong)
    __swig_getmethods__["SetAsUnsignedLong"] = lambda x: SetAsUnsignedLong
    def SetAsNumericalScalar(*args):
        """SetAsNumericalScalar(OT::String key, OT::NumericalScalar value)"""
        return _common.ResourceMap_SetAsNumericalScalar(*args)

    if _newclass:SetAsNumericalScalar = staticmethod(SetAsNumericalScalar)
    __swig_getmethods__["SetAsNumericalScalar"] = lambda x: SetAsNumericalScalar
    def __repr__(self):
        """__repr__(ResourceMap self) -> OT::String"""
        return _common.ResourceMap___repr__(self)

    __swig_destroy__ = _common.delete_ResourceMap
    __del__ = lambda self : None;
ResourceMap_swigregister = _common.ResourceMap_swigregister
ResourceMap_swigregister(ResourceMap)

def ResourceMap_GetInstance():
  """ResourceMap_GetInstance() -> ResourceMapInstance"""
  return _common.ResourceMap_GetInstance()

def ResourceMap_Release():
  """ResourceMap_Release()"""
  return _common.ResourceMap_Release()

def ResourceMap_Initialize():
  """ResourceMap_Initialize()"""
  return _common.ResourceMap_Initialize()

def ResourceMap_Get(*args):
  """ResourceMap_Get(OT::String key) -> OT::String"""
  return _common.ResourceMap_Get(*args)

def ResourceMap_GetAsBool(*args):
  """ResourceMap_GetAsBool(OT::String key) -> OT::Bool"""
  return _common.ResourceMap_GetAsBool(*args)

def ResourceMap_GetAsUnsignedLong(*args):
  """ResourceMap_GetAsUnsignedLong(OT::String key) -> OT::UnsignedLong"""
  return _common.ResourceMap_GetAsUnsignedLong(*args)

def ResourceMap_GetAsNumericalScalar(*args):
  """ResourceMap_GetAsNumericalScalar(OT::String key) -> OT::NumericalScalar"""
  return _common.ResourceMap_GetAsNumericalScalar(*args)

def ResourceMap_GetAsNewCharArray(*args):
  """ResourceMap_GetAsNewCharArray(OT::String key) -> char *"""
  return _common.ResourceMap_GetAsNewCharArray(*args)

def ResourceMap_Set(*args):
  """ResourceMap_Set(OT::String key, OT::String value)"""
  return _common.ResourceMap_Set(*args)

def ResourceMap_SetAsBool(*args):
  """ResourceMap_SetAsBool(OT::String key, OT::Bool value)"""
  return _common.ResourceMap_SetAsBool(*args)

def ResourceMap_SetAsUnsignedLong(*args):
  """ResourceMap_SetAsUnsignedLong(OT::String key, OT::UnsignedLong value)"""
  return _common.ResourceMap_SetAsUnsignedLong(*args)

def ResourceMap_SetAsNumericalScalar(*args):
  """ResourceMap_SetAsNumericalScalar(OT::String key, OT::NumericalScalar value)"""
  return _common.ResourceMap_SetAsNumericalScalar(*args)

class ResourceMap_init(_object):
    """Proxy of C++ OT::ResourceMap_init class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceMap_init, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResourceMap_init, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::ResourceMap_init self) -> ResourceMap_init"""
        this = _common.new_ResourceMap_init()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_ResourceMap_init
    __del__ = lambda self : None;
ResourceMap_init_swigregister = _common.ResourceMap_init_swigregister
ResourceMap_init_swigregister(ResourceMap_init)


def __lshift__(*args):
  """__lshift__(std::ostream & os, ResourceMapInstance obj) -> std::ostream &"""
  return _common.__lshift__(*args)
class ComparisonOperatorImplementation(PersistentObject):
    """Proxy of C++ OT::ComparisonOperatorImplementation class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperatorImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperatorImplementation, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.ComparisonOperatorImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComparisonOperatorImplementation self) -> OT::String"""
        return _common.ComparisonOperatorImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(ComparisonOperatorImplementation self) -> OT::String"""
        return _common.ComparisonOperatorImplementation___repr__(self)

    def __call__(self, *args):
        """__call__(ComparisonOperatorImplementation self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.ComparisonOperatorImplementation___call__(self, *args)

    __swig_destroy__ = _common.delete_ComparisonOperatorImplementation
    __del__ = lambda self : None;
ComparisonOperatorImplementation_swigregister = _common.ComparisonOperatorImplementation_swigregister
ComparisonOperatorImplementation_swigregister(ComparisonOperatorImplementation)

def ComparisonOperatorImplementation_GetClassName():
  """ComparisonOperatorImplementation_GetClassName() -> OT::String"""
  return _common.ComparisonOperatorImplementation_GetClassName()

class ComparisonOperatorImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::ComparisonOperatorImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperatorImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperatorImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::ComparisonOperatorImplementation)> self) -> ComparisonOperatorImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::ComparisonOperatorImplementation)> self, ComparisonOperatorImplementationPointer impl) -> ComparisonOperatorImplementationTypedInterfaceObject
        """
        this = _common.new_ComparisonOperatorImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(ComparisonOperatorImplementationTypedInterfaceObject self) -> ComparisonOperatorImplementationPointer
        getImplementation(ComparisonOperatorImplementationTypedInterfaceObject self) -> ComparisonOperatorImplementationPointer
        """
        return _common.ComparisonOperatorImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ComparisonOperatorImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _common.ComparisonOperatorImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ComparisonOperatorImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _common.ComparisonOperatorImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ComparisonOperatorImplementationTypedInterfaceObject self, ComparisonOperatorImplementationTypedInterfaceObject other)"""
        return _common.ComparisonOperatorImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ComparisonOperatorImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _common.ComparisonOperatorImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ComparisonOperatorImplementationTypedInterfaceObject self) -> OT::String"""
        return _common.ComparisonOperatorImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ComparisonOperatorImplementationTypedInterfaceObject self, ComparisonOperatorImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _common.delete_ComparisonOperatorImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ComparisonOperatorImplementationTypedInterfaceObject_swigregister = _common.ComparisonOperatorImplementationTypedInterfaceObject_swigregister
ComparisonOperatorImplementationTypedInterfaceObject_swigregister(ComparisonOperatorImplementationTypedInterfaceObject)

class ComparisonOperator(ComparisonOperatorImplementationTypedInterfaceObject):
    """Proxy of C++ OT::ComparisonOperator class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperator, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.ComparisonOperator_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComparisonOperator self) -> OT::String"""
        return _common.ComparisonOperator_getClassName(self)

    def __call__(self, *args):
        """__call__(ComparisonOperator self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.ComparisonOperator___call__(self, *args)

    def compare(self, *args):
        """compare(ComparisonOperator self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.ComparisonOperator_compare(self, *args)

    def __str__(self):
        """__str__(ComparisonOperator self) -> OT::String const"""
        return _common.ComparisonOperator___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComparisonOperator self) -> ComparisonOperator
        __init__(OT::ComparisonOperator self, ComparisonOperatorImplementation op) -> ComparisonOperator
        __init__(OT::ComparisonOperator self, ComparisonOperator other) -> ComparisonOperator
        """
        this = _common.new_ComparisonOperator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_ComparisonOperator
    __del__ = lambda self : None;
ComparisonOperator_swigregister = _common.ComparisonOperator_swigregister
ComparisonOperator_swigregister(ComparisonOperator)

def ComparisonOperator_GetClassName():
  """ComparisonOperator_GetClassName() -> OT::String"""
  return _common.ComparisonOperator_GetClassName()

class Equal(ComparisonOperatorImplementation):
    """Proxy of C++ OT::Equal class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Equal, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Equal, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.Equal_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Equal self) -> OT::String"""
        return _common.Equal_getClassName(self)

    def __repr__(self):
        """__repr__(Equal self) -> OT::String"""
        return _common.Equal___repr__(self)

    def __call__(self, *args):
        """__call__(Equal self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.Equal___call__(self, *args)

    def __str__(self):
        """__str__(Equal self) -> OT::String const"""
        return _common.Equal___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Equal self) -> Equal
        __init__(OT::Equal self, Equal other) -> Equal
        """
        this = _common.new_Equal(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_Equal
    __del__ = lambda self : None;
Equal_swigregister = _common.Equal_swigregister
Equal_swigregister(Equal)

def Equal_GetClassName():
  """Equal_GetClassName() -> OT::String"""
  return _common.Equal_GetClassName()

class Greater(ComparisonOperatorImplementation):
    """Proxy of C++ OT::Greater class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Greater, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Greater, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.Greater_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Greater self) -> OT::String"""
        return _common.Greater_getClassName(self)

    def __repr__(self):
        """__repr__(Greater self) -> OT::String"""
        return _common.Greater___repr__(self)

    def __call__(self, *args):
        """__call__(Greater self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.Greater___call__(self, *args)

    def __str__(self):
        """__str__(Greater self) -> OT::String const"""
        return _common.Greater___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Greater self) -> Greater
        __init__(OT::Greater self, Greater other) -> Greater
        """
        this = _common.new_Greater(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_Greater
    __del__ = lambda self : None;
Greater_swigregister = _common.Greater_swigregister
Greater_swigregister(Greater)

def Greater_GetClassName():
  """Greater_GetClassName() -> OT::String"""
  return _common.Greater_GetClassName()

class GreaterOrEqual(ComparisonOperatorImplementation):
    """Proxy of C++ OT::GreaterOrEqual class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GreaterOrEqual, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GreaterOrEqual, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.GreaterOrEqual_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GreaterOrEqual self) -> OT::String"""
        return _common.GreaterOrEqual_getClassName(self)

    def __repr__(self):
        """__repr__(GreaterOrEqual self) -> OT::String"""
        return _common.GreaterOrEqual___repr__(self)

    def __call__(self, *args):
        """__call__(GreaterOrEqual self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.GreaterOrEqual___call__(self, *args)

    def __str__(self):
        """__str__(GreaterOrEqual self) -> OT::String const"""
        return _common.GreaterOrEqual___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::GreaterOrEqual self) -> GreaterOrEqual
        __init__(OT::GreaterOrEqual self, GreaterOrEqual other) -> GreaterOrEqual
        """
        this = _common.new_GreaterOrEqual(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_GreaterOrEqual
    __del__ = lambda self : None;
GreaterOrEqual_swigregister = _common.GreaterOrEqual_swigregister
GreaterOrEqual_swigregister(GreaterOrEqual)

def GreaterOrEqual_GetClassName():
  """GreaterOrEqual_GetClassName() -> OT::String"""
  return _common.GreaterOrEqual_GetClassName()

class Less(ComparisonOperatorImplementation):
    """Proxy of C++ OT::Less class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Less, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Less, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.Less_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Less self) -> OT::String"""
        return _common.Less_getClassName(self)

    def __repr__(self):
        """__repr__(Less self) -> OT::String"""
        return _common.Less___repr__(self)

    def __call__(self, *args):
        """__call__(Less self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.Less___call__(self, *args)

    def __str__(self):
        """__str__(Less self) -> OT::String const"""
        return _common.Less___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Less self) -> Less
        __init__(OT::Less self, Less other) -> Less
        """
        this = _common.new_Less(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_Less
    __del__ = lambda self : None;
Less_swigregister = _common.Less_swigregister
Less_swigregister(Less)

def Less_GetClassName():
  """Less_GetClassName() -> OT::String"""
  return _common.Less_GetClassName()

class LessOrEqual(ComparisonOperatorImplementation):
    """Proxy of C++ OT::LessOrEqual class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LessOrEqual, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LessOrEqual, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _common.LessOrEqual_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LessOrEqual self) -> OT::String"""
        return _common.LessOrEqual_getClassName(self)

    def __repr__(self):
        """__repr__(LessOrEqual self) -> OT::String"""
        return _common.LessOrEqual___repr__(self)

    def __call__(self, *args):
        """__call__(LessOrEqual self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.LessOrEqual___call__(self, *args)

    def __str__(self):
        """__str__(LessOrEqual self) -> OT::String const"""
        return _common.LessOrEqual___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LessOrEqual self) -> LessOrEqual
        __init__(OT::LessOrEqual self, LessOrEqual other) -> LessOrEqual
        """
        this = _common.new_LessOrEqual(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_LessOrEqual
    __del__ = lambda self : None;
LessOrEqual_swigregister = _common.LessOrEqual_swigregister
LessOrEqual_swigregister(LessOrEqual)

def LessOrEqual_GetClassName():
  """LessOrEqual_GetClassName() -> OT::String"""
  return _common.LessOrEqual_GetClassName()

class Threadable(_object):
    """Proxy of C++ OT::Threadable class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Threadable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Threadable, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_Threadable
    __del__ = lambda self : None;
    def run(self):
        """run(Threadable self)"""
        return _common.Threadable_run(self)

Threadable_swigregister = _common.Threadable_swigregister
Threadable_swigregister(Threadable)

class PlatformInfo(_object):
    """Proxy of C++ OT::PlatformInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlatformInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PlatformInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def GetVersion():
        """GetVersion() -> OT::String"""
        return _common.PlatformInfo_GetVersion()

    if _newclass:GetVersion = staticmethod(GetVersion)
    __swig_getmethods__["GetVersion"] = lambda x: GetVersion
    def GetName():
        """GetName() -> OT::String"""
        return _common.PlatformInfo_GetName()

    if _newclass:GetName = staticmethod(GetName)
    __swig_getmethods__["GetName"] = lambda x: GetName
    def GetRevision():
        """GetRevision() -> OT::String"""
        return _common.PlatformInfo_GetRevision()

    if _newclass:GetRevision = staticmethod(GetRevision)
    __swig_getmethods__["GetRevision"] = lambda x: GetRevision
    def GetDate():
        """GetDate() -> OT::String"""
        return _common.PlatformInfo_GetDate()

    if _newclass:GetDate = staticmethod(GetDate)
    __swig_getmethods__["GetDate"] = lambda x: GetDate
    def GetInstallationDirectory():
        """GetInstallationDirectory() -> OT::String"""
        return _common.PlatformInfo_GetInstallationDirectory()

    if _newclass:GetInstallationDirectory = staticmethod(GetInstallationDirectory)
    __swig_getmethods__["GetInstallationDirectory"] = lambda x: GetInstallationDirectory
    def GetModuleDirectory():
        """GetModuleDirectory() -> OT::String"""
        return _common.PlatformInfo_GetModuleDirectory()

    if _newclass:GetModuleDirectory = staticmethod(GetModuleDirectory)
    __swig_getmethods__["GetModuleDirectory"] = lambda x: GetModuleDirectory
    def GetConfigureCommandLine():
        """GetConfigureCommandLine() -> OT::String"""
        return _common.PlatformInfo_GetConfigureCommandLine()

    if _newclass:GetConfigureCommandLine = staticmethod(GetConfigureCommandLine)
    __swig_getmethods__["GetConfigureCommandLine"] = lambda x: GetConfigureCommandLine
    def GetNumericalPrecision():
        """GetNumericalPrecision() -> OT::UnsignedLong"""
        return _common.PlatformInfo_GetNumericalPrecision()

    if _newclass:GetNumericalPrecision = staticmethod(GetNumericalPrecision)
    __swig_getmethods__["GetNumericalPrecision"] = lambda x: GetNumericalPrecision
    def SetNumericalPrecision(*args):
        """SetNumericalPrecision(OT::SignedInteger precision)"""
        return _common.PlatformInfo_SetNumericalPrecision(*args)

    if _newclass:SetNumericalPrecision = staticmethod(SetNumericalPrecision)
    __swig_getmethods__["SetNumericalPrecision"] = lambda x: SetNumericalPrecision
    __swig_destroy__ = _common.delete_PlatformInfo
    __del__ = lambda self : None;
PlatformInfo_swigregister = _common.PlatformInfo_swigregister
PlatformInfo_swigregister(PlatformInfo)

def PlatformInfo_GetVersion():
  """PlatformInfo_GetVersion() -> OT::String"""
  return _common.PlatformInfo_GetVersion()

def PlatformInfo_GetName():
  """PlatformInfo_GetName() -> OT::String"""
  return _common.PlatformInfo_GetName()

def PlatformInfo_GetRevision():
  """PlatformInfo_GetRevision() -> OT::String"""
  return _common.PlatformInfo_GetRevision()

def PlatformInfo_GetDate():
  """PlatformInfo_GetDate() -> OT::String"""
  return _common.PlatformInfo_GetDate()

def PlatformInfo_GetInstallationDirectory():
  """PlatformInfo_GetInstallationDirectory() -> OT::String"""
  return _common.PlatformInfo_GetInstallationDirectory()

def PlatformInfo_GetModuleDirectory():
  """PlatformInfo_GetModuleDirectory() -> OT::String"""
  return _common.PlatformInfo_GetModuleDirectory()

def PlatformInfo_GetConfigureCommandLine():
  """PlatformInfo_GetConfigureCommandLine() -> OT::String"""
  return _common.PlatformInfo_GetConfigureCommandLine()

def PlatformInfo_GetNumericalPrecision():
  """PlatformInfo_GetNumericalPrecision() -> OT::UnsignedLong"""
  return _common.PlatformInfo_GetNumericalPrecision()

def PlatformInfo_SetNumericalPrecision(*args):
  """PlatformInfo_SetNumericalPrecision(OT::SignedInteger precision)"""
  return _common.PlatformInfo_SetNumericalPrecision(*args)

class MPICommunicator(_object):
    """Proxy of C++ OT::MPICommunicator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MPICommunicator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MPICommunicator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::MPICommunicator self, OT::MPICommunicator::CommunicatorType const & communicator) -> MPICommunicator
        __init__(OT::MPICommunicator self, MPICommunicator other) -> MPICommunicator
        """
        this = _common.new_MPICommunicator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_MPICommunicator
    __del__ = lambda self : None;
    def GetCommWorld():
        """GetCommWorld() -> MPICommunicator"""
        return _common.MPICommunicator_GetCommWorld()

    if _newclass:GetCommWorld = staticmethod(GetCommWorld)
    __swig_getmethods__["GetCommWorld"] = lambda x: GetCommWorld
MPICommunicator_swigregister = _common.MPICommunicator_swigregister
MPICommunicator_swigregister(MPICommunicator)

def MPICommunicator_GetCommWorld():
  """MPICommunicator_GetCommWorld() -> MPICommunicator"""
  return _common.MPICommunicator_GetCommWorld()

class MPI(_object):
    """Proxy of C++ OT::MPI class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MPI, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MPI, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_MPI
    __del__ = lambda self : None;
    def Init(*args):
        """Init(MPICommunicator comm)"""
        return _common.MPI_Init(*args)

    if _newclass:Init = staticmethod(Init)
    __swig_getmethods__["Init"] = lambda x: Init
    def Release():
        """Release()"""
        return _common.MPI_Release()

    if _newclass:Release = staticmethod(Release)
    __swig_getmethods__["Release"] = lambda x: Release
MPI_swigregister = _common.MPI_swigregister
MPI_swigregister(MPI)

def MPI_Init(*args):
  """MPI_Init(MPICommunicator comm)"""
  return _common.MPI_Init(*args)

def MPI_Release():
  """MPI_Release()"""
  return _common.MPI_Release()

class ComparisonOperatorImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::ComparisonOperatorImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperatorImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperatorImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _common.ComparisonOperatorImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _common.ComparisonOperatorImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_common.ComparisonOperatorImplementationPointer_ptr__get, _common.ComparisonOperatorImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::ComparisonOperatorImplementation)> self) -> ComparisonOperatorImplementationPointer
        __init__(OT::Pointer<(OT::ComparisonOperatorImplementation)> self, ComparisonOperatorImplementation ptr) -> ComparisonOperatorImplementationPointer
        """
        this = _common.new_ComparisonOperatorImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_ComparisonOperatorImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(ComparisonOperatorImplementationPointer self)"""
        return _common.ComparisonOperatorImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(ComparisonOperatorImplementationPointer self) -> ComparisonOperatorImplementation
        __ref__(ComparisonOperatorImplementationPointer self) -> ComparisonOperatorImplementation
        """
        return _common.ComparisonOperatorImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(ComparisonOperatorImplementationPointer self) -> ComparisonOperatorImplementation"""
        return _common.ComparisonOperatorImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(ComparisonOperatorImplementationPointer self) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _common.ComparisonOperatorImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(ComparisonOperatorImplementationPointer self) -> ComparisonOperatorImplementation"""
        return _common.ComparisonOperatorImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(ComparisonOperatorImplementationPointer self) -> OT::Pointer< OT::ComparisonOperatorImplementation >::pointer_type const &"""
        return _common.ComparisonOperatorImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(ComparisonOperatorImplementationPointer self) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer_unique(self)

    def use_count(self):
        """use_count(ComparisonOperatorImplementationPointer self) -> OT::UnsignedLong"""
        return _common.ComparisonOperatorImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(ComparisonOperatorImplementationPointer self, ComparisonOperatorImplementationPointer other)"""
        return _common.ComparisonOperatorImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(ComparisonOperatorImplementationPointer self) -> OT::String"""
        return _common.ComparisonOperatorImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(ComparisonOperatorImplementationPointer self) -> OT::String"""
        return _common.ComparisonOperatorImplementationPointer_getClassName(self)

    def __repr__(self):
        """__repr__(ComparisonOperatorImplementationPointer self) -> OT::String"""
        return _common.ComparisonOperatorImplementationPointer___repr__(self)

    def __call__(self, *args):
        """__call__(ComparisonOperatorImplementationPointer self, OT::NumericalScalar a, OT::NumericalScalar b) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer___call__(self, *args)

    def __eq__(self, *args):
        """__eq__(ComparisonOperatorImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(ComparisonOperatorImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer_Is(self, *args)

    def __str__(self, offset=""):
        """
        __str__(ComparisonOperatorImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(ComparisonOperatorImplementationPointer self) -> OT::String
        """
        return _common.ComparisonOperatorImplementationPointer___str__(self, offset)

    def getId(self):
        """getId(ComparisonOperatorImplementationPointer self) -> OT::Id"""
        return _common.ComparisonOperatorImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(ComparisonOperatorImplementationPointer self, OT::Id id)"""
        return _common.ComparisonOperatorImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(ComparisonOperatorImplementationPointer self) -> OT::Id"""
        return _common.ComparisonOperatorImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(ComparisonOperatorImplementationPointer self, OT::Bool visible)"""
        return _common.ComparisonOperatorImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(ComparisonOperatorImplementationPointer self) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(ComparisonOperatorImplementationPointer self) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(ComparisonOperatorImplementationPointer self) -> OT::Bool"""
        return _common.ComparisonOperatorImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(ComparisonOperatorImplementationPointer self) -> OT::String"""
        return _common.ComparisonOperatorImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(ComparisonOperatorImplementationPointer self, OT::String const & name)"""
        return _common.ComparisonOperatorImplementationPointer_setName(self, *args)

ComparisonOperatorImplementationPointer_swigregister = _common.ComparisonOperatorImplementationPointer_swigregister
ComparisonOperatorImplementationPointer_swigregister(ComparisonOperatorImplementationPointer)

class PersistentObjectPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::PersistentObject)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PersistentObjectPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PersistentObjectPointer, name)
    __swig_setmethods__["ptr_"] = _common.PersistentObjectPointer_ptr__set
    __swig_getmethods__["ptr_"] = _common.PersistentObjectPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_common.PersistentObjectPointer_ptr__get, _common.PersistentObjectPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::PersistentObject)> self) -> PersistentObjectPointer
        __init__(OT::Pointer<(OT::PersistentObject)> self, PersistentObject ptr) -> PersistentObjectPointer
        """
        this = _common.new_PersistentObjectPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_PersistentObjectPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(PersistentObjectPointer self)"""
        return _common.PersistentObjectPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(PersistentObjectPointer self) -> PersistentObject
        __ref__(PersistentObjectPointer self) -> PersistentObject
        """
        return _common.PersistentObjectPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(PersistentObjectPointer self) -> PersistentObject"""
        return _common.PersistentObjectPointer___deref__(self)

    def isNull(self):
        """isNull(PersistentObjectPointer self) -> OT::Bool"""
        return _common.PersistentObjectPointer_isNull(self)

    def __nonzero__(self):
        return _common.PersistentObjectPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(PersistentObjectPointer self) -> PersistentObject"""
        return _common.PersistentObjectPointer_get(self)

    def getImplementation(self):
        """getImplementation(PersistentObjectPointer self) -> OT::Pointer< OT::PersistentObject >::pointer_type const &"""
        return _common.PersistentObjectPointer_getImplementation(self)

    def unique(self):
        """unique(PersistentObjectPointer self) -> OT::Bool"""
        return _common.PersistentObjectPointer_unique(self)

    def use_count(self):
        """use_count(PersistentObjectPointer self) -> OT::UnsignedLong"""
        return _common.PersistentObjectPointer_use_count(self)

    def swap(self, *args):
        """swap(PersistentObjectPointer self, PersistentObjectPointer other)"""
        return _common.PersistentObjectPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(PersistentObjectPointer self) -> OT::String"""
        return _common.PersistentObjectPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(PersistentObjectPointer self) -> OT::String"""
        return _common.PersistentObjectPointer_getClassName(self)

    def __eq__(self, *args):
        """__eq__(PersistentObjectPointer self, PersistentObject other) -> OT::Bool"""
        return _common.PersistentObjectPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(PersistentObjectPointer self, PersistentObject other) -> OT::Bool"""
        return _common.PersistentObjectPointer_Is(self, *args)

    def __repr__(self):
        """__repr__(PersistentObjectPointer self) -> OT::String"""
        return _common.PersistentObjectPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PersistentObjectPointer self, OT::String const & offset="") -> OT::String
        __str__(PersistentObjectPointer self) -> OT::String
        """
        return _common.PersistentObjectPointer___str__(self, offset)

    def getId(self):
        """getId(PersistentObjectPointer self) -> OT::Id"""
        return _common.PersistentObjectPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(PersistentObjectPointer self, OT::Id id)"""
        return _common.PersistentObjectPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(PersistentObjectPointer self) -> OT::Id"""
        return _common.PersistentObjectPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(PersistentObjectPointer self, OT::Bool visible)"""
        return _common.PersistentObjectPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(PersistentObjectPointer self) -> OT::Bool"""
        return _common.PersistentObjectPointer_getVisibility(self)

    def hasName(self):
        """hasName(PersistentObjectPointer self) -> OT::Bool"""
        return _common.PersistentObjectPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(PersistentObjectPointer self) -> OT::Bool"""
        return _common.PersistentObjectPointer_hasVisibleName(self)

    def getName(self):
        """getName(PersistentObjectPointer self) -> OT::String"""
        return _common.PersistentObjectPointer_getName(self)

    def setName(self, *args):
        """setName(PersistentObjectPointer self, OT::String const & name)"""
        return _common.PersistentObjectPointer_setName(self, *args)

PersistentObjectPointer_swigregister = _common.PersistentObjectPointer_swigregister
PersistentObjectPointer_swigregister(PersistentObjectPointer)

class StorageManagerPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::StorageManager)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StorageManagerPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StorageManagerPointer, name)
    __swig_setmethods__["ptr_"] = _common.StorageManagerPointer_ptr__set
    __swig_getmethods__["ptr_"] = _common.StorageManagerPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_common.StorageManagerPointer_ptr__get, _common.StorageManagerPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::StorageManager)> self) -> StorageManagerPointer
        __init__(OT::Pointer<(OT::StorageManager)> self, StorageManager ptr) -> StorageManagerPointer
        """
        this = _common.new_StorageManagerPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_StorageManagerPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(StorageManagerPointer self)"""
        return _common.StorageManagerPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(StorageManagerPointer self) -> StorageManager
        __ref__(StorageManagerPointer self) -> StorageManager
        """
        return _common.StorageManagerPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(StorageManagerPointer self) -> StorageManager"""
        return _common.StorageManagerPointer___deref__(self)

    def isNull(self):
        """isNull(StorageManagerPointer self) -> OT::Bool"""
        return _common.StorageManagerPointer_isNull(self)

    def __nonzero__(self):
        return _common.StorageManagerPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(StorageManagerPointer self) -> StorageManager"""
        return _common.StorageManagerPointer_get(self)

    def getImplementation(self):
        """getImplementation(StorageManagerPointer self) -> OT::Pointer< OT::StorageManager >::pointer_type const &"""
        return _common.StorageManagerPointer_getImplementation(self)

    def unique(self):
        """unique(StorageManagerPointer self) -> OT::Bool"""
        return _common.StorageManagerPointer_unique(self)

    def use_count(self):
        """use_count(StorageManagerPointer self) -> OT::UnsignedLong"""
        return _common.StorageManagerPointer_use_count(self)

    def swap(self, *args):
        """swap(StorageManagerPointer self, StorageManagerPointer other)"""
        return _common.StorageManagerPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(StorageManagerPointer self) -> OT::String"""
        return _common.StorageManagerPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(StorageManagerPointer self) -> OT::String"""
        return _common.StorageManagerPointer_getClassName(self)

    def __repr__(self):
        """__repr__(StorageManagerPointer self) -> OT::String"""
        return _common.StorageManagerPointer___repr__(self)

    def save(self, *args):
        """
        save(StorageManagerPointer self, PersistentObject obj, OT::String const & label, bool fromStudy=False)
        save(StorageManagerPointer self, PersistentObject obj, OT::String const & label)
        """
        return _common.StorageManagerPointer_save(self, *args)

    def load(self, *args):
        """load(StorageManagerPointer self, Study study)"""
        return _common.StorageManagerPointer_load(self, *args)

    def getStudy(self):
        """getStudy(StorageManagerPointer self) -> Study"""
        return _common.StorageManagerPointer_getStudy(self)

    def setStudy(self, *args):
        """setStudy(StorageManagerPointer self, Study p_study)"""
        return _common.StorageManagerPointer_setStudy(self, *args)

    def getDefaultStudyVersion(self):
        """getDefaultStudyVersion(StorageManagerPointer self) -> OT::UnsignedLong"""
        return _common.StorageManagerPointer_getDefaultStudyVersion(self)

    def getStudyVersion(self):
        """getStudyVersion(StorageManagerPointer self) -> OT::UnsignedLong"""
        return _common.StorageManagerPointer_getStudyVersion(self)

    def setStudyVersion(self, *args):
        """setStudyVersion(StorageManagerPointer self, OT::UnsignedLong version)"""
        return _common.StorageManagerPointer_setStudyVersion(self, *args)

    def initialize(self, *args):
        """
        initialize(StorageManagerPointer self, SaveAction caller)
        initialize(StorageManagerPointer self, LoadAction caller)
        """
        return _common.StorageManagerPointer_initialize(self, *args)

    def finalize(self, *args):
        """
        finalize(StorageManagerPointer self, SaveAction caller)
        finalize(StorageManagerPointer self, LoadAction caller)
        """
        return _common.StorageManagerPointer_finalize(self, *args)

    def read(self):
        """read(StorageManagerPointer self)"""
        return _common.StorageManagerPointer_read(self)

    def write(self):
        """write(StorageManagerPointer self)"""
        return _common.StorageManagerPointer_write(self)

    def isSavedObject(self, *args):
        """isSavedObject(StorageManagerPointer self, OT::Id id) -> OT::Bool"""
        return _common.StorageManagerPointer_isSavedObject(self, *args)

    def markObjectAsSaved(self, *args):
        """markObjectAsSaved(StorageManagerPointer self, OT::Id id)"""
        return _common.StorageManagerPointer_markObjectAsSaved(self, *args)

    def __str__(self, offset=""):
        """
        __str__(StorageManagerPointer self, OT::String const & offset="") -> OT::String
        __str__(StorageManagerPointer self) -> OT::String
        """
        return _common.StorageManagerPointer___str__(self, offset)

StorageManagerPointer_swigregister = _common.StorageManagerPointer_swigregister
StorageManagerPointer_swigregister(StorageManagerPointer)

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