python-openturns 1.2-2 / usr / share / pyshared / openturns / wrapper.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.


"""
Wrapping utilities.
"""


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


def makeVariableList( vars ):
  """
  Transform the vars list into a WrapperVariableList structure
  ex : vars = ({ "id_" : "F", "type_" : WrapperDataVariableType.IN  },
                    { "id_" : "E", "type_" : WrapperDataVariableType.IN  },
                    { "id_" : "Z", "type_" : WrapperDataVariableType.OUT },
                    )
            varlist = makeVariableList( vars )

        Note: The keys of the dictionary are the field of the WrapperDataVariable structure.
  """
  vl = WrapperDataVariableCollection()
  for var in vars:
    if var.__class__ == dict().__class__ :
      v = WrapperDataVariable()
      for key in var.keys():
        v.__setattr__( key, var[key] )
      vl.add( v )
  return vl

def makeFileList( files ):
  """
  Transform the files list into a WrapperFileList structure
  ex : files = ({ "id_" : "infile",  "type_" : WrapperDataFileType.IN,
                        "path_" : "/tmp/inFILE",  "subst_" : "E,F"
                      },
                      { "id_" : "outfile", "type_" : WrapperDataFileType.OUT,
                        "path_" : "/tmp/outFILE", "subst_" : "Z"
                      },
                      )
              filelist = makeFileList( files )

        Note: The keys of the dictionary are the field of the WrapperDataFile structure.
  """
  fl = WrapperDataFileCollection()
  for file in files:
    if file.__class__ == dict().__class__ :
      f = WrapperDataFile()
      for key in file.keys():
        f.__setattr__( key, file[key] )
      fl.add( f )
  return fl

def makeParameters( params ):
  """
  Transform the params dictionnary into a WrapperParameter structure
  ex : params = { "command_" : "/path/to/my/code < someredir > anotherredir",
                        "userPrefix_" : "MyCode",
                      }
            parameters = makeParameters( params )

        Note: The keys of the dictionary are the field of the WrapperParameter structure.
  """
  p = WrapperParameter()
  for key in params.keys():
    p.__setattr__( key, params[key] )
  return p

def makeFramework( fw ):
  """
  Transform the fw dictionnary into a WrapperFramework structure
  ex : fw = { "studyid_" : 1733,
                    "studycase_" : "SalomeOpenTURNS_testcase",
                    "componentname_" : "SalomeOpenTURNSComponent"
                  }
            framework = makeFramework( fw )

        Note: The keys of the dictionary are the field of the WrapperFrameworkData structure.
  """
  f = WrapperFrameworkData()
  for key in fw.keys():
    f.__setattr__( key, fw[key] )
  return f

def makeWrapper( vars, files, params, framework ):
  """
  Build a new WrapperFile object from the data provided by the "generic" wrapper
  and replace them with the data from vars, files, params and framework.
  See docstring for makeVariableList(), makeFileList(), makeParameters() and
  makeFramework() functions to get the actual structure of these arguments.
  """
  wrp = WrapperFile.FindWrapperByName( "generic" )
  wd = wrp.getWrapperData()
  vl = makeVariableList( vars )
  wd.setVariableList( vl )
  fl = makeFileList( files )
  wd.setFileList( fl )
  wp = makeParameters( params )
  wd.setParameters( wp )
  fw = makeFramework( framework )
  wd.setFrameworkData( fw )
  wrp.setWrapperData( wd )
  return wrp

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__ = _wrapper.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _wrapper.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GCC_VERSION = _wrapper.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

import openturns.common
WRAPPER_OK = _wrapper.WRAPPER_OK
WRAPPER_MEMORY_ERROR = _wrapper.WRAPPER_MEMORY_ERROR
WRAPPER_INITIALIZATION_ERROR = _wrapper.WRAPPER_INITIALIZATION_ERROR
WRAPPER_EXECUTION_ERROR = _wrapper.WRAPPER_EXECUTION_ERROR
WRAPPER_FINALIZATION_ERROR = _wrapper.WRAPPER_FINALIZATION_ERROR
WRAPPER_CANNOT_CREATE_STATE = _wrapper.WRAPPER_CANNOT_CREATE_STATE
WRAPPER_CANNOT_DELETE_STATE = _wrapper.WRAPPER_CANNOT_DELETE_STATE
WRAPPER_CANNOT_PROVIDE_INFORMATION = _wrapper.WRAPPER_CANNOT_PROVIDE_INFORMATION
WRAPPER_INTERNAL_ERROR = _wrapper.WRAPPER_INTERNAL_ERROR
WRAPPER_WRONG_ARGUMENT = _wrapper.WRAPPER_WRONG_ARGUMENT
WRAPPER_USAGE_ERROR = _wrapper.WRAPPER_USAGE_ERROR
WRAPPER_NOT_IMPLEMENTED = _wrapper.WRAPPER_NOT_IMPLEMENTED
WRAPPER_EXECUTION_ERROR_NO_RETRY = _wrapper.WRAPPER_EXECUTION_ERROR_NO_RETRY
WRAPPER_BIND_ERROR = _wrapper.WRAPPER_BIND_ERROR
UNUSED_ERROR = _wrapper.UNUSED_ERROR
class WrapperInformation(_object):
    """Proxy of C++ WrapperInformation class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperInformation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperInformation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["inSize_"] = _wrapper.WrapperInformation_inSize__set
    __swig_getmethods__["inSize_"] = _wrapper.WrapperInformation_inSize__get
    if _newclass:inSize_ = _swig_property(_wrapper.WrapperInformation_inSize__get, _wrapper.WrapperInformation_inSize__set)
    __swig_setmethods__["outSize_"] = _wrapper.WrapperInformation_outSize__set
    __swig_getmethods__["outSize_"] = _wrapper.WrapperInformation_outSize__get
    if _newclass:outSize_ = _swig_property(_wrapper.WrapperInformation_outSize__get, _wrapper.WrapperInformation_outSize__set)
    def __init__(self): 
        """__init__(WrapperInformation self) -> WrapperInformation"""
        this = _wrapper.new_WrapperInformation()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperInformation
    __del__ = lambda self : None;
WrapperInformation_swigregister = _wrapper.WrapperInformation_swigregister
WrapperInformation_swigregister(WrapperInformation)

class point(_object):
    """Proxy of C++ point class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, point, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, point, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size_"] = _wrapper.point_size__set
    __swig_getmethods__["size_"] = _wrapper.point_size__get
    if _newclass:size_ = _swig_property(_wrapper.point_size__get, _wrapper.point_size__set)
    __swig_setmethods__["data_"] = _wrapper.point_data__set
    __swig_getmethods__["data_"] = _wrapper.point_data__get
    if _newclass:data_ = _swig_property(_wrapper.point_data__get, _wrapper.point_data__set)
    def __init__(self): 
        """__init__(point self) -> point"""
        this = _wrapper.new_point()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_point
    __del__ = lambda self : None;
point_swigregister = _wrapper.point_swigregister
point_swigregister(point)

class sample(_object):
    """Proxy of C++ sample class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sample, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sample, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size_"] = _wrapper.sample_size__set
    __swig_getmethods__["size_"] = _wrapper.sample_size__get
    if _newclass:size_ = _swig_property(_wrapper.sample_size__get, _wrapper.sample_size__set)
    __swig_setmethods__["dimension_"] = _wrapper.sample_dimension__set
    __swig_getmethods__["dimension_"] = _wrapper.sample_dimension__get
    if _newclass:dimension_ = _swig_property(_wrapper.sample_dimension__get, _wrapper.sample_dimension__set)
    __swig_setmethods__["data_"] = _wrapper.sample_data__set
    __swig_getmethods__["data_"] = _wrapper.sample_data__get
    if _newclass:data_ = _swig_property(_wrapper.sample_data__get, _wrapper.sample_data__set)
    def __init__(self): 
        """__init__(sample self) -> sample"""
        this = _wrapper.new_sample()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_sample
    __del__ = lambda self : None;
sample_swigregister = _wrapper.sample_swigregister
sample_swigregister(sample)

class timeseries(_object):
    """Proxy of C++ timeseries class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, timeseries, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, timeseries, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size_"] = _wrapper.timeseries_size__set
    __swig_getmethods__["size_"] = _wrapper.timeseries_size__get
    if _newclass:size_ = _swig_property(_wrapper.timeseries_size__get, _wrapper.timeseries_size__set)
    __swig_setmethods__["dimension_"] = _wrapper.timeseries_dimension__set
    __swig_getmethods__["dimension_"] = _wrapper.timeseries_dimension__get
    if _newclass:dimension_ = _swig_property(_wrapper.timeseries_dimension__get, _wrapper.timeseries_dimension__set)
    __swig_setmethods__["data_"] = _wrapper.timeseries_data__set
    __swig_getmethods__["data_"] = _wrapper.timeseries_data__get
    if _newclass:data_ = _swig_property(_wrapper.timeseries_data__get, _wrapper.timeseries_data__set)
    def __init__(self): 
        """__init__(timeseries self) -> timeseries"""
        this = _wrapper.new_timeseries()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_timeseries
    __del__ = lambda self : None;
timeseries_swigregister = _wrapper.timeseries_swigregister
timeseries_swigregister(timeseries)

class matrix(_object):
    """Proxy of C++ matrix class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, matrix, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nbrows_"] = _wrapper.matrix_nbrows__set
    __swig_getmethods__["nbrows_"] = _wrapper.matrix_nbrows__get
    if _newclass:nbrows_ = _swig_property(_wrapper.matrix_nbrows__get, _wrapper.matrix_nbrows__set)
    __swig_setmethods__["nbcols_"] = _wrapper.matrix_nbcols__set
    __swig_getmethods__["nbcols_"] = _wrapper.matrix_nbcols__get
    if _newclass:nbcols_ = _swig_property(_wrapper.matrix_nbcols__get, _wrapper.matrix_nbcols__set)
    __swig_setmethods__["data_"] = _wrapper.matrix_data__set
    __swig_getmethods__["data_"] = _wrapper.matrix_data__get
    if _newclass:data_ = _swig_property(_wrapper.matrix_data__get, _wrapper.matrix_data__set)
    def __init__(self): 
        """__init__(matrix self) -> matrix"""
        this = _wrapper.new_matrix()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_matrix
    __del__ = lambda self : None;
matrix_swigregister = _wrapper.matrix_swigregister
matrix_swigregister(matrix)

class tensor(_object):
    """Proxy of C++ tensor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, tensor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, tensor, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nbrows_"] = _wrapper.tensor_nbrows__set
    __swig_getmethods__["nbrows_"] = _wrapper.tensor_nbrows__get
    if _newclass:nbrows_ = _swig_property(_wrapper.tensor_nbrows__get, _wrapper.tensor_nbrows__set)
    __swig_setmethods__["nbcols_"] = _wrapper.tensor_nbcols__set
    __swig_getmethods__["nbcols_"] = _wrapper.tensor_nbcols__get
    if _newclass:nbcols_ = _swig_property(_wrapper.tensor_nbcols__get, _wrapper.tensor_nbcols__set)
    __swig_setmethods__["nbsheets_"] = _wrapper.tensor_nbsheets__set
    __swig_getmethods__["nbsheets_"] = _wrapper.tensor_nbsheets__get
    if _newclass:nbsheets_ = _swig_property(_wrapper.tensor_nbsheets__get, _wrapper.tensor_nbsheets__set)
    __swig_setmethods__["data_"] = _wrapper.tensor_data__set
    __swig_getmethods__["data_"] = _wrapper.tensor_data__get
    if _newclass:data_ = _swig_property(_wrapper.tensor_data__get, _wrapper.tensor_data__set)
    def __init__(self): 
        """__init__(tensor self) -> tensor"""
        this = _wrapper.new_tensor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_tensor
    __del__ = lambda self : None;
tensor_swigregister = _wrapper.tensor_swigregister
tensor_swigregister(tensor)

WRAPPER_IN = _wrapper.WRAPPER_IN
WRAPPER_OUT = _wrapper.WRAPPER_OUT
WRAPPER_INTERNAL = _wrapper.WRAPPER_INTERNAL
UNUSED_LISTELEMENT = _wrapper.UNUSED_LISTELEMENT
WRAPPER_NO = _wrapper.WRAPPER_NO
WRAPPER_YES = _wrapper.WRAPPER_YES
UNUSED_PROVIDED = _wrapper.UNUSED_PROVIDED
WRAPPER_LINE = _wrapper.WRAPPER_LINE
WRAPPER_REGEXP = _wrapper.WRAPPER_REGEXP
UNUSED_LOCATION = _wrapper.UNUSED_LOCATION
class WrapperFileListElement(_object):
    """Proxy of C++ WrapperFileListElement class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFileListElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFileListElement, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id_"] = _wrapper.WrapperFileListElement_id__set
    __swig_getmethods__["id_"] = _wrapper.WrapperFileListElement_id__get
    if _newclass:id_ = _swig_property(_wrapper.WrapperFileListElement_id__get, _wrapper.WrapperFileListElement_id__set)
    __swig_setmethods__["name_"] = _wrapper.WrapperFileListElement_name__set
    __swig_getmethods__["name_"] = _wrapper.WrapperFileListElement_name__get
    if _newclass:name_ = _swig_property(_wrapper.WrapperFileListElement_name__get, _wrapper.WrapperFileListElement_name__set)
    __swig_setmethods__["path_"] = _wrapper.WrapperFileListElement_path__set
    __swig_getmethods__["path_"] = _wrapper.WrapperFileListElement_path__get
    if _newclass:path_ = _swig_property(_wrapper.WrapperFileListElement_path__get, _wrapper.WrapperFileListElement_path__set)
    __swig_setmethods__["subst_"] = _wrapper.WrapperFileListElement_subst__set
    __swig_getmethods__["subst_"] = _wrapper.WrapperFileListElement_subst__get
    if _newclass:subst_ = _swig_property(_wrapper.WrapperFileListElement_subst__get, _wrapper.WrapperFileListElement_subst__set)
    __swig_setmethods__["type_"] = _wrapper.WrapperFileListElement_type__set
    __swig_getmethods__["type_"] = _wrapper.WrapperFileListElement_type__get
    if _newclass:type_ = _swig_property(_wrapper.WrapperFileListElement_type__get, _wrapper.WrapperFileListElement_type__set)
    def __init__(self): 
        """__init__(WrapperFileListElement self) -> WrapperFileListElement"""
        this = _wrapper.new_WrapperFileListElement()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperFileListElement
    __del__ = lambda self : None;
WrapperFileListElement_swigregister = _wrapper.WrapperFileListElement_swigregister
WrapperFileListElement_swigregister(WrapperFileListElement)

class WrapperFileList(_object):
    """Proxy of C++ WrapperFileList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFileList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFileList, name)
    __repr__ = _swig_repr
    __swig_setmethods__["next_"] = _wrapper.WrapperFileList_next__set
    __swig_getmethods__["next_"] = _wrapper.WrapperFileList_next__get
    if _newclass:next_ = _swig_property(_wrapper.WrapperFileList_next__get, _wrapper.WrapperFileList_next__set)
    __swig_setmethods__["file_"] = _wrapper.WrapperFileList_file__set
    __swig_getmethods__["file_"] = _wrapper.WrapperFileList_file__get
    if _newclass:file_ = _swig_property(_wrapper.WrapperFileList_file__get, _wrapper.WrapperFileList_file__set)
    def __init__(self): 
        """__init__(WrapperFileList self) -> WrapperFileList"""
        this = _wrapper.new_WrapperFileList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperFileList
    __del__ = lambda self : None;
WrapperFileList_swigregister = _wrapper.WrapperFileList_swigregister
WrapperFileList_swigregister(WrapperFileList)

class WrapperVariableListElement(_object):
    """Proxy of C++ WrapperVariableListElement class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperVariableListElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperVariableListElement, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id_"] = _wrapper.WrapperVariableListElement_id__set
    __swig_getmethods__["id_"] = _wrapper.WrapperVariableListElement_id__get
    if _newclass:id_ = _swig_property(_wrapper.WrapperVariableListElement_id__get, _wrapper.WrapperVariableListElement_id__set)
    __swig_setmethods__["comment_"] = _wrapper.WrapperVariableListElement_comment__set
    __swig_getmethods__["comment_"] = _wrapper.WrapperVariableListElement_comment__get
    if _newclass:comment_ = _swig_property(_wrapper.WrapperVariableListElement_comment__get, _wrapper.WrapperVariableListElement_comment__set)
    __swig_setmethods__["unit_"] = _wrapper.WrapperVariableListElement_unit__set
    __swig_getmethods__["unit_"] = _wrapper.WrapperVariableListElement_unit__get
    if _newclass:unit_ = _swig_property(_wrapper.WrapperVariableListElement_unit__get, _wrapper.WrapperVariableListElement_unit__set)
    __swig_setmethods__["regexp_"] = _wrapper.WrapperVariableListElement_regexp__set
    __swig_getmethods__["regexp_"] = _wrapper.WrapperVariableListElement_regexp__get
    if _newclass:regexp_ = _swig_property(_wrapper.WrapperVariableListElement_regexp__get, _wrapper.WrapperVariableListElement_regexp__set)
    __swig_setmethods__["format_"] = _wrapper.WrapperVariableListElement_format__set
    __swig_getmethods__["format_"] = _wrapper.WrapperVariableListElement_format__get
    if _newclass:format_ = _swig_property(_wrapper.WrapperVariableListElement_format__get, _wrapper.WrapperVariableListElement_format__set)
    __swig_setmethods__["type_"] = _wrapper.WrapperVariableListElement_type__set
    __swig_getmethods__["type_"] = _wrapper.WrapperVariableListElement_type__get
    if _newclass:type_ = _swig_property(_wrapper.WrapperVariableListElement_type__get, _wrapper.WrapperVariableListElement_type__set)
    __swig_setmethods__["gradient_"] = _wrapper.WrapperVariableListElement_gradient__set
    __swig_getmethods__["gradient_"] = _wrapper.WrapperVariableListElement_gradient__get
    if _newclass:gradient_ = _swig_property(_wrapper.WrapperVariableListElement_gradient__get, _wrapper.WrapperVariableListElement_gradient__set)
    __swig_setmethods__["fromType_"] = _wrapper.WrapperVariableListElement_fromType__set
    __swig_getmethods__["fromType_"] = _wrapper.WrapperVariableListElement_fromType__get
    if _newclass:fromType_ = _swig_property(_wrapper.WrapperVariableListElement_fromType__get, _wrapper.WrapperVariableListElement_fromType__set)
    __swig_setmethods__["from_"] = _wrapper.WrapperVariableListElement_from__set
    __swig_getmethods__["from_"] = _wrapper.WrapperVariableListElement_from__get
    if _newclass:from_ = _swig_property(_wrapper.WrapperVariableListElement_from__get, _wrapper.WrapperVariableListElement_from__set)
    __swig_setmethods__["toType_"] = _wrapper.WrapperVariableListElement_toType__set
    __swig_getmethods__["toType_"] = _wrapper.WrapperVariableListElement_toType__get
    if _newclass:toType_ = _swig_property(_wrapper.WrapperVariableListElement_toType__get, _wrapper.WrapperVariableListElement_toType__set)
    __swig_setmethods__["to_"] = _wrapper.WrapperVariableListElement_to__set
    __swig_getmethods__["to_"] = _wrapper.WrapperVariableListElement_to__get
    if _newclass:to_ = _swig_property(_wrapper.WrapperVariableListElement_to__get, _wrapper.WrapperVariableListElement_to__set)
    def __init__(self): 
        """__init__(WrapperVariableListElement self) -> WrapperVariableListElement"""
        this = _wrapper.new_WrapperVariableListElement()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperVariableListElement
    __del__ = lambda self : None;
WrapperVariableListElement_swigregister = _wrapper.WrapperVariableListElement_swigregister
WrapperVariableListElement_swigregister(WrapperVariableListElement)

class WrapperVariableList(_object):
    """Proxy of C++ WrapperVariableList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperVariableList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperVariableList, name)
    __repr__ = _swig_repr
    __swig_setmethods__["next_"] = _wrapper.WrapperVariableList_next__set
    __swig_getmethods__["next_"] = _wrapper.WrapperVariableList_next__get
    if _newclass:next_ = _swig_property(_wrapper.WrapperVariableList_next__get, _wrapper.WrapperVariableList_next__set)
    __swig_setmethods__["variable_"] = _wrapper.WrapperVariableList_variable__set
    __swig_getmethods__["variable_"] = _wrapper.WrapperVariableList_variable__get
    if _newclass:variable_ = _swig_property(_wrapper.WrapperVariableList_variable__get, _wrapper.WrapperVariableList_variable__set)
    def __init__(self): 
        """__init__(WrapperVariableList self) -> WrapperVariableList"""
        this = _wrapper.new_WrapperVariableList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperVariableList
    __del__ = lambda self : None;
WrapperVariableList_swigregister = _wrapper.WrapperVariableList_swigregister
WrapperVariableList_swigregister(WrapperVariableList)

WRAPPER_SHAREDSTATE = _wrapper.WRAPPER_SHAREDSTATE
WRAPPER_SPECIFICSTATE = _wrapper.WRAPPER_SPECIFICSTATE
UNUSED_CONFIGURATIONSTATE = _wrapper.UNUSED_CONFIGURATIONSTATE
WRAPPER_STATICLINK = _wrapper.WRAPPER_STATICLINK
WRAPPER_DYNAMICLINK = _wrapper.WRAPPER_DYNAMICLINK
WRAPPER_FORK = _wrapper.WRAPPER_FORK
UNUSED_CONFIGURATIONMODE = _wrapper.UNUSED_CONFIGURATIONMODE
WRAPPER_FILES = _wrapper.WRAPPER_FILES
WRAPPER_PIPE = _wrapper.WRAPPER_PIPE
WRAPPER_ARGUMENTS = _wrapper.WRAPPER_ARGUMENTS
WRAPPER_SOCKET = _wrapper.WRAPPER_SOCKET
WRAPPER_CORBA = _wrapper.WRAPPER_CORBA
UNUSED_DATATRANSFERMODE = _wrapper.UNUSED_DATATRANSFERMODE
class WrapperConfiguration(_object):
    """Proxy of C++ WrapperConfiguration class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperConfiguration, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperConfiguration, name)
    __repr__ = _swig_repr
    __swig_setmethods__["state_"] = _wrapper.WrapperConfiguration_state__set
    __swig_getmethods__["state_"] = _wrapper.WrapperConfiguration_state__get
    if _newclass:state_ = _swig_property(_wrapper.WrapperConfiguration_state__get, _wrapper.WrapperConfiguration_state__set)
    __swig_setmethods__["mode_"] = _wrapper.WrapperConfiguration_mode__set
    __swig_getmethods__["mode_"] = _wrapper.WrapperConfiguration_mode__get
    if _newclass:mode_ = _swig_property(_wrapper.WrapperConfiguration_mode__get, _wrapper.WrapperConfiguration_mode__set)
    __swig_setmethods__["in_"] = _wrapper.WrapperConfiguration_in__set
    __swig_getmethods__["in_"] = _wrapper.WrapperConfiguration_in__get
    if _newclass:in_ = _swig_property(_wrapper.WrapperConfiguration_in__get, _wrapper.WrapperConfiguration_in__set)
    __swig_setmethods__["out_"] = _wrapper.WrapperConfiguration_out__set
    __swig_getmethods__["out_"] = _wrapper.WrapperConfiguration_out__get
    if _newclass:out_ = _swig_property(_wrapper.WrapperConfiguration_out__get, _wrapper.WrapperConfiguration_out__set)
    __swig_setmethods__["command_"] = _wrapper.WrapperConfiguration_command__set
    __swig_getmethods__["command_"] = _wrapper.WrapperConfiguration_command__get
    if _newclass:command_ = _swig_property(_wrapper.WrapperConfiguration_command__get, _wrapper.WrapperConfiguration_command__set)
    __swig_setmethods__["userPrefix_"] = _wrapper.WrapperConfiguration_userPrefix__set
    __swig_getmethods__["userPrefix_"] = _wrapper.WrapperConfiguration_userPrefix__get
    if _newclass:userPrefix_ = _swig_property(_wrapper.WrapperConfiguration_userPrefix__get, _wrapper.WrapperConfiguration_userPrefix__set)
    def __init__(self): 
        """__init__(WrapperConfiguration self) -> WrapperConfiguration"""
        this = _wrapper.new_WrapperConfiguration()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperConfiguration
    __del__ = lambda self : None;
WrapperConfiguration_swigregister = _wrapper.WrapperConfiguration_swigregister
WrapperConfiguration_swigregister(WrapperConfiguration)

class PlatformConfiguration(_object):
    """Proxy of C++ PlatformConfiguration class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlatformConfiguration, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PlatformConfiguration, name)
    __repr__ = _swig_repr
    __swig_setmethods__["generalTemporaryDirectory_"] = _wrapper.PlatformConfiguration_generalTemporaryDirectory__set
    __swig_getmethods__["generalTemporaryDirectory_"] = _wrapper.PlatformConfiguration_generalTemporaryDirectory__get
    if _newclass:generalTemporaryDirectory_ = _swig_property(_wrapper.PlatformConfiguration_generalTemporaryDirectory__get, _wrapper.PlatformConfiguration_generalTemporaryDirectory__set)
    __swig_setmethods__["realRegexpShortcut_"] = _wrapper.PlatformConfiguration_realRegexpShortcut__set
    __swig_getmethods__["realRegexpShortcut_"] = _wrapper.PlatformConfiguration_realRegexpShortcut__get
    if _newclass:realRegexpShortcut_ = _swig_property(_wrapper.PlatformConfiguration_realRegexpShortcut__get, _wrapper.PlatformConfiguration_realRegexpShortcut__set)
    __swig_setmethods__["integerRegexpShortcut_"] = _wrapper.PlatformConfiguration_integerRegexpShortcut__set
    __swig_getmethods__["integerRegexpShortcut_"] = _wrapper.PlatformConfiguration_integerRegexpShortcut__get
    if _newclass:integerRegexpShortcut_ = _swig_property(_wrapper.PlatformConfiguration_integerRegexpShortcut__get, _wrapper.PlatformConfiguration_integerRegexpShortcut__set)
    __swig_setmethods__["separatorRegexpShortcut_"] = _wrapper.PlatformConfiguration_separatorRegexpShortcut__set
    __swig_getmethods__["separatorRegexpShortcut_"] = _wrapper.PlatformConfiguration_separatorRegexpShortcut__get
    if _newclass:separatorRegexpShortcut_ = _swig_property(_wrapper.PlatformConfiguration_separatorRegexpShortcut__get, _wrapper.PlatformConfiguration_separatorRegexpShortcut__set)
    __swig_setmethods__["nbCpus_"] = _wrapper.PlatformConfiguration_nbCpus__set
    __swig_getmethods__["nbCpus_"] = _wrapper.PlatformConfiguration_nbCpus__get
    if _newclass:nbCpus_ = _swig_property(_wrapper.PlatformConfiguration_nbCpus__get, _wrapper.PlatformConfiguration_nbCpus__set)
    __swig_setmethods__["outputFilesTimeout_"] = _wrapper.PlatformConfiguration_outputFilesTimeout__set
    __swig_getmethods__["outputFilesTimeout_"] = _wrapper.PlatformConfiguration_outputFilesTimeout__get
    if _newclass:outputFilesTimeout_ = _swig_property(_wrapper.PlatformConfiguration_outputFilesTimeout__get, _wrapper.PlatformConfiguration_outputFilesTimeout__set)
    __swig_setmethods__["retries_"] = _wrapper.PlatformConfiguration_retries__set
    __swig_getmethods__["retries_"] = _wrapper.PlatformConfiguration_retries__get
    if _newclass:retries_ = _swig_property(_wrapper.PlatformConfiguration_retries__get, _wrapper.PlatformConfiguration_retries__set)
    __swig_setmethods__["command_path_"] = _wrapper.PlatformConfiguration_command_path__set
    __swig_getmethods__["command_path_"] = _wrapper.PlatformConfiguration_command_path__get
    if _newclass:command_path_ = _swig_property(_wrapper.PlatformConfiguration_command_path__get, _wrapper.PlatformConfiguration_command_path__set)
    def __init__(self): 
        """__init__(PlatformConfiguration self) -> PlatformConfiguration"""
        this = _wrapper.new_PlatformConfiguration()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_PlatformConfiguration
    __del__ = lambda self : None;
PlatformConfiguration_swigregister = _wrapper.PlatformConfiguration_swigregister
PlatformConfiguration_swigregister(PlatformConfiguration)

class FrameworkData(_object):
    """Proxy of C++ FrameworkData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FrameworkData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FrameworkData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["studyid_"] = _wrapper.FrameworkData_studyid__set
    __swig_getmethods__["studyid_"] = _wrapper.FrameworkData_studyid__get
    if _newclass:studyid_ = _swig_property(_wrapper.FrameworkData_studyid__get, _wrapper.FrameworkData_studyid__set)
    __swig_setmethods__["studycase_"] = _wrapper.FrameworkData_studycase__set
    __swig_getmethods__["studycase_"] = _wrapper.FrameworkData_studycase__get
    if _newclass:studycase_ = _swig_property(_wrapper.FrameworkData_studycase__get, _wrapper.FrameworkData_studycase__set)
    __swig_setmethods__["componentname_"] = _wrapper.FrameworkData_componentname__set
    __swig_getmethods__["componentname_"] = _wrapper.FrameworkData_componentname__get
    if _newclass:componentname_ = _swig_property(_wrapper.FrameworkData_componentname__get, _wrapper.FrameworkData_componentname__set)
    def __init__(self): 
        """__init__(FrameworkData self) -> FrameworkData"""
        this = _wrapper.new_FrameworkData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_FrameworkData
    __del__ = lambda self : None;
FrameworkData_swigregister = _wrapper.FrameworkData_swigregister
FrameworkData_swigregister(FrameworkData)

class WrapperExchangedData(_object):
    """Proxy of C++ WrapperExchangedData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperExchangedData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperExchangedData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fileList_"] = _wrapper.WrapperExchangedData_fileList__set
    __swig_getmethods__["fileList_"] = _wrapper.WrapperExchangedData_fileList__get
    if _newclass:fileList_ = _swig_property(_wrapper.WrapperExchangedData_fileList__get, _wrapper.WrapperExchangedData_fileList__set)
    __swig_setmethods__["variableList_"] = _wrapper.WrapperExchangedData_variableList__set
    __swig_getmethods__["variableList_"] = _wrapper.WrapperExchangedData_variableList__get
    if _newclass:variableList_ = _swig_property(_wrapper.WrapperExchangedData_variableList__get, _wrapper.WrapperExchangedData_variableList__set)
    __swig_setmethods__["parameters_"] = _wrapper.WrapperExchangedData_parameters__set
    __swig_getmethods__["parameters_"] = _wrapper.WrapperExchangedData_parameters__get
    if _newclass:parameters_ = _swig_property(_wrapper.WrapperExchangedData_parameters__get, _wrapper.WrapperExchangedData_parameters__set)
    __swig_setmethods__["platform_"] = _wrapper.WrapperExchangedData_platform__set
    __swig_getmethods__["platform_"] = _wrapper.WrapperExchangedData_platform__get
    if _newclass:platform_ = _swig_property(_wrapper.WrapperExchangedData_platform__get, _wrapper.WrapperExchangedData_platform__set)
    __swig_setmethods__["framework_"] = _wrapper.WrapperExchangedData_framework__set
    __swig_getmethods__["framework_"] = _wrapper.WrapperExchangedData_framework__get
    if _newclass:framework_ = _swig_property(_wrapper.WrapperExchangedData_framework__get, _wrapper.WrapperExchangedData_framework__set)
    __swig_setmethods__["p_lock_"] = _wrapper.WrapperExchangedData_p_lock__set
    __swig_getmethods__["p_lock_"] = _wrapper.WrapperExchangedData_p_lock__get
    if _newclass:p_lock_ = _swig_property(_wrapper.WrapperExchangedData_p_lock__get, _wrapper.WrapperExchangedData_p_lock__set)
    def __init__(self): 
        """__init__(WrapperExchangedData self) -> WrapperExchangedData"""
        this = _wrapper.new_WrapperExchangedData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperExchangedData
    __del__ = lambda self : None;
WrapperExchangedData_swigregister = _wrapper.WrapperExchangedData_swigregister
WrapperExchangedData_swigregister(WrapperExchangedData)

class WrapperSymbolProvided(_object):
    """Proxy of C++ OT::WrapperSymbolProvided class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperSymbolProvided, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperSymbolProvided, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperSymbolProvided self) -> WrapperSymbolProvided"""
        this = _wrapper.new_WrapperSymbolProvided()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperSymbolProvided
    __del__ = lambda self : None;
WrapperSymbolProvided_swigregister = _wrapper.WrapperSymbolProvided_swigregister
WrapperSymbolProvided_swigregister(WrapperSymbolProvided)
cvar = _wrapper.cvar
WrapperSymbolProvided.NO = _wrapper.cvar.WrapperSymbolProvided_NO
WrapperSymbolProvided.YES = _wrapper.cvar.WrapperSymbolProvided_YES

class WrapperComputedGradient(_object):
    """Proxy of C++ OT::WrapperComputedGradient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperComputedGradient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperComputedGradient, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperComputedGradient self) -> WrapperComputedGradient"""
        this = _wrapper.new_WrapperComputedGradient()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperComputedGradient
    __del__ = lambda self : None;
WrapperComputedGradient_swigregister = _wrapper.WrapperComputedGradient_swigregister
WrapperComputedGradient_swigregister(WrapperComputedGradient)
WrapperComputedGradient.NO = _wrapper.cvar.WrapperComputedGradient_NO
WrapperComputedGradient.YES = _wrapper.cvar.WrapperComputedGradient_YES

class WrapperFunctionDescription(openturns.common.Object):
    """Proxy of C++ OT::WrapperFunctionDescription class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFunctionDescription, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFunctionDescription, name)
    __swig_setmethods__["name_"] = _wrapper.WrapperFunctionDescription_name__set
    __swig_getmethods__["name_"] = _wrapper.WrapperFunctionDescription_name__get
    if _newclass:name_ = _swig_property(_wrapper.WrapperFunctionDescription_name__get, _wrapper.WrapperFunctionDescription_name__set)
    __swig_setmethods__["provided_"] = _wrapper.WrapperFunctionDescription_provided__set
    __swig_getmethods__["provided_"] = _wrapper.WrapperFunctionDescription_provided__get
    if _newclass:provided_ = _swig_property(_wrapper.WrapperFunctionDescription_provided__get, _wrapper.WrapperFunctionDescription_provided__set)
    def __init__(self): 
        """__init__(OT::WrapperFunctionDescription self) -> WrapperFunctionDescription"""
        this = _wrapper.new_WrapperFunctionDescription()
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(WrapperFunctionDescription self) -> OT::String"""
        return _wrapper.WrapperFunctionDescription___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperFunctionDescription self, OT::String const & offset="") -> OT::String
        __str__(WrapperFunctionDescription self) -> OT::String
        """
        return _wrapper.WrapperFunctionDescription___str__(self, offset)

    __swig_destroy__ = _wrapper.delete_WrapperFunctionDescription
    __del__ = lambda self : None;
WrapperFunctionDescription_swigregister = _wrapper.WrapperFunctionDescription_swigregister
WrapperFunctionDescription_swigregister(WrapperFunctionDescription)

class WrapperDataFileType(_object):
    """Proxy of C++ OT::WrapperDataFileType class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataFileType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataFileType, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperDataFileType self) -> WrapperDataFileType"""
        this = _wrapper.new_WrapperDataFileType()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperDataFileType
    __del__ = lambda self : None;
WrapperDataFileType_swigregister = _wrapper.WrapperDataFileType_swigregister
WrapperDataFileType_swigregister(WrapperDataFileType)
WrapperDataFileType.IN = _wrapper.cvar.WrapperDataFileType_IN
WrapperDataFileType.OUT = _wrapper.cvar.WrapperDataFileType_OUT

class WrapperDataFile(openturns.common.Object):
    """Proxy of C++ OT::WrapperDataFile class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataFile, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataFile, name)
    __swig_setmethods__["id_"] = _wrapper.WrapperDataFile_id__set
    __swig_getmethods__["id_"] = _wrapper.WrapperDataFile_id__get
    if _newclass:id_ = _swig_property(_wrapper.WrapperDataFile_id__get, _wrapper.WrapperDataFile_id__set)
    __swig_setmethods__["name_"] = _wrapper.WrapperDataFile_name__set
    __swig_getmethods__["name_"] = _wrapper.WrapperDataFile_name__get
    if _newclass:name_ = _swig_property(_wrapper.WrapperDataFile_name__get, _wrapper.WrapperDataFile_name__set)
    __swig_setmethods__["path_"] = _wrapper.WrapperDataFile_path__set
    __swig_getmethods__["path_"] = _wrapper.WrapperDataFile_path__get
    if _newclass:path_ = _swig_property(_wrapper.WrapperDataFile_path__get, _wrapper.WrapperDataFile_path__set)
    __swig_setmethods__["subst_"] = _wrapper.WrapperDataFile_subst__set
    __swig_getmethods__["subst_"] = _wrapper.WrapperDataFile_subst__get
    if _newclass:subst_ = _swig_property(_wrapper.WrapperDataFile_subst__get, _wrapper.WrapperDataFile_subst__set)
    __swig_setmethods__["type_"] = _wrapper.WrapperDataFile_type__set
    __swig_getmethods__["type_"] = _wrapper.WrapperDataFile_type__get
    if _newclass:type_ = _swig_property(_wrapper.WrapperDataFile_type__get, _wrapper.WrapperDataFile_type__set)
    def __init__(self): 
        """__init__(OT::WrapperDataFile self) -> WrapperDataFile"""
        this = _wrapper.new_WrapperDataFile()
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """__eq__(WrapperDataFile self, WrapperDataFile other) -> OT::Bool"""
        return _wrapper.WrapperDataFile___eq__(self, *args)

    def __repr__(self):
        """__repr__(WrapperDataFile self) -> OT::String"""
        return _wrapper.WrapperDataFile___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperDataFile self, OT::String const & offset="") -> OT::String
        __str__(WrapperDataFile self) -> OT::String
        """
        return _wrapper.WrapperDataFile___str__(self, offset)

    __swig_destroy__ = _wrapper.delete_WrapperDataFile
    __del__ = lambda self : None;
WrapperDataFile_swigregister = _wrapper.WrapperDataFile_swigregister
WrapperDataFile_swigregister(WrapperDataFile)

class WrapperFrameworkData(openturns.common.Object):
    """Proxy of C++ OT::WrapperFrameworkData class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFrameworkData, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFrameworkData, name)
    __swig_setmethods__["studyid_"] = _wrapper.WrapperFrameworkData_studyid__set
    __swig_getmethods__["studyid_"] = _wrapper.WrapperFrameworkData_studyid__get
    if _newclass:studyid_ = _swig_property(_wrapper.WrapperFrameworkData_studyid__get, _wrapper.WrapperFrameworkData_studyid__set)
    __swig_setmethods__["studycase_"] = _wrapper.WrapperFrameworkData_studycase__set
    __swig_getmethods__["studycase_"] = _wrapper.WrapperFrameworkData_studycase__get
    if _newclass:studycase_ = _swig_property(_wrapper.WrapperFrameworkData_studycase__get, _wrapper.WrapperFrameworkData_studycase__set)
    __swig_setmethods__["componentname_"] = _wrapper.WrapperFrameworkData_componentname__set
    __swig_getmethods__["componentname_"] = _wrapper.WrapperFrameworkData_componentname__get
    if _newclass:componentname_ = _swig_property(_wrapper.WrapperFrameworkData_componentname__get, _wrapper.WrapperFrameworkData_componentname__set)
    def __init__(self): 
        """__init__(OT::WrapperFrameworkData self) -> WrapperFrameworkData"""
        this = _wrapper.new_WrapperFrameworkData()
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(WrapperFrameworkData self) -> OT::String"""
        return _wrapper.WrapperFrameworkData___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperFrameworkData self, OT::String const & offset="") -> OT::String
        __str__(WrapperFrameworkData self) -> OT::String
        """
        return _wrapper.WrapperFrameworkData___str__(self, offset)

    __swig_destroy__ = _wrapper.delete_WrapperFrameworkData
    __del__ = lambda self : None;
WrapperFrameworkData_swigregister = _wrapper.WrapperFrameworkData_swigregister
WrapperFrameworkData_swigregister(WrapperFrameworkData)

class WrapperDataVariableType(_object):
    """Proxy of C++ OT::WrapperDataVariableType class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariableType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariableType, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperDataVariableType self) -> WrapperDataVariableType"""
        this = _wrapper.new_WrapperDataVariableType()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperDataVariableType
    __del__ = lambda self : None;
WrapperDataVariableType_swigregister = _wrapper.WrapperDataVariableType_swigregister
WrapperDataVariableType_swigregister(WrapperDataVariableType)
WrapperDataVariableType.IN = _wrapper.cvar.WrapperDataVariableType_IN
WrapperDataVariableType.OUT = _wrapper.cvar.WrapperDataVariableType_OUT
WrapperDataVariableType.INTERNAL = _wrapper.cvar.WrapperDataVariableType_INTERNAL

class WrapperDataVariableLocation(_object):
    """Proxy of C++ OT::WrapperDataVariableLocation class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariableLocation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariableLocation, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperDataVariableLocation self) -> WrapperDataVariableLocation"""
        this = _wrapper.new_WrapperDataVariableLocation()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperDataVariableLocation
    __del__ = lambda self : None;
WrapperDataVariableLocation_swigregister = _wrapper.WrapperDataVariableLocation_swigregister
WrapperDataVariableLocation_swigregister(WrapperDataVariableLocation)
WrapperDataVariableLocation.LINE = _wrapper.cvar.WrapperDataVariableLocation_LINE
WrapperDataVariableLocation.REGEXP = _wrapper.cvar.WrapperDataVariableLocation_REGEXP

class WrapperDataVariable(openturns.common.Object):
    """Proxy of C++ OT::WrapperDataVariable class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariable, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariable, name)
    __swig_setmethods__["id_"] = _wrapper.WrapperDataVariable_id__set
    __swig_getmethods__["id_"] = _wrapper.WrapperDataVariable_id__get
    if _newclass:id_ = _swig_property(_wrapper.WrapperDataVariable_id__get, _wrapper.WrapperDataVariable_id__set)
    __swig_setmethods__["comment_"] = _wrapper.WrapperDataVariable_comment__set
    __swig_getmethods__["comment_"] = _wrapper.WrapperDataVariable_comment__get
    if _newclass:comment_ = _swig_property(_wrapper.WrapperDataVariable_comment__get, _wrapper.WrapperDataVariable_comment__set)
    __swig_setmethods__["unit_"] = _wrapper.WrapperDataVariable_unit__set
    __swig_getmethods__["unit_"] = _wrapper.WrapperDataVariable_unit__get
    if _newclass:unit_ = _swig_property(_wrapper.WrapperDataVariable_unit__get, _wrapper.WrapperDataVariable_unit__set)
    __swig_setmethods__["regexp_"] = _wrapper.WrapperDataVariable_regexp__set
    __swig_getmethods__["regexp_"] = _wrapper.WrapperDataVariable_regexp__get
    if _newclass:regexp_ = _swig_property(_wrapper.WrapperDataVariable_regexp__get, _wrapper.WrapperDataVariable_regexp__set)
    __swig_setmethods__["format_"] = _wrapper.WrapperDataVariable_format__set
    __swig_getmethods__["format_"] = _wrapper.WrapperDataVariable_format__get
    if _newclass:format_ = _swig_property(_wrapper.WrapperDataVariable_format__get, _wrapper.WrapperDataVariable_format__set)
    __swig_setmethods__["type_"] = _wrapper.WrapperDataVariable_type__set
    __swig_getmethods__["type_"] = _wrapper.WrapperDataVariable_type__get
    if _newclass:type_ = _swig_property(_wrapper.WrapperDataVariable_type__get, _wrapper.WrapperDataVariable_type__set)
    __swig_setmethods__["gradient_"] = _wrapper.WrapperDataVariable_gradient__set
    __swig_getmethods__["gradient_"] = _wrapper.WrapperDataVariable_gradient__get
    if _newclass:gradient_ = _swig_property(_wrapper.WrapperDataVariable_gradient__get, _wrapper.WrapperDataVariable_gradient__set)
    __swig_setmethods__["fromType_"] = _wrapper.WrapperDataVariable_fromType__set
    __swig_getmethods__["fromType_"] = _wrapper.WrapperDataVariable_fromType__get
    if _newclass:fromType_ = _swig_property(_wrapper.WrapperDataVariable_fromType__get, _wrapper.WrapperDataVariable_fromType__set)
    __swig_setmethods__["from_"] = _wrapper.WrapperDataVariable_from__set
    __swig_getmethods__["from_"] = _wrapper.WrapperDataVariable_from__get
    if _newclass:from_ = _swig_property(_wrapper.WrapperDataVariable_from__get, _wrapper.WrapperDataVariable_from__set)
    __swig_setmethods__["toType_"] = _wrapper.WrapperDataVariable_toType__set
    __swig_getmethods__["toType_"] = _wrapper.WrapperDataVariable_toType__get
    if _newclass:toType_ = _swig_property(_wrapper.WrapperDataVariable_toType__get, _wrapper.WrapperDataVariable_toType__set)
    __swig_setmethods__["to_"] = _wrapper.WrapperDataVariable_to__set
    __swig_getmethods__["to_"] = _wrapper.WrapperDataVariable_to__get
    if _newclass:to_ = _swig_property(_wrapper.WrapperDataVariable_to__get, _wrapper.WrapperDataVariable_to__set)
    def __init__(self): 
        """__init__(OT::WrapperDataVariable self) -> WrapperDataVariable"""
        this = _wrapper.new_WrapperDataVariable()
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """__eq__(WrapperDataVariable self, WrapperDataVariable other) -> OT::Bool"""
        return _wrapper.WrapperDataVariable___eq__(self, *args)

    def __repr__(self):
        """__repr__(WrapperDataVariable self) -> OT::String"""
        return _wrapper.WrapperDataVariable___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperDataVariable self, OT::String const & offset="") -> OT::String
        __str__(WrapperDataVariable self) -> OT::String
        """
        return _wrapper.WrapperDataVariable___str__(self, offset)

    __swig_destroy__ = _wrapper.delete_WrapperDataVariable
    __del__ = lambda self : None;
WrapperDataVariable_swigregister = _wrapper.WrapperDataVariable_swigregister
WrapperDataVariable_swigregister(WrapperDataVariable)

class WrapperState(_object):
    """Proxy of C++ OT::WrapperState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperState, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperState self) -> WrapperState"""
        this = _wrapper.new_WrapperState()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperState
    __del__ = lambda self : None;
WrapperState_swigregister = _wrapper.WrapperState_swigregister
WrapperState_swigregister(WrapperState)
WrapperState.SHARED = _wrapper.cvar.WrapperState_SHARED
WrapperState.SPECIFIC = _wrapper.cvar.WrapperState_SPECIFIC

class WrapperMode(_object):
    """Proxy of C++ OT::WrapperMode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperMode, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperMode self) -> WrapperMode"""
        this = _wrapper.new_WrapperMode()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperMode
    __del__ = lambda self : None;
WrapperMode_swigregister = _wrapper.WrapperMode_swigregister
WrapperMode_swigregister(WrapperMode)
WrapperMode.STATICLINK = _wrapper.cvar.WrapperMode_STATICLINK
WrapperMode.DYNAMICLINK = _wrapper.cvar.WrapperMode_DYNAMICLINK
WrapperMode.FORK = _wrapper.cvar.WrapperMode_FORK

class WrapperDataTransfer(_object):
    """Proxy of C++ OT::WrapperDataTransfer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataTransfer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataTransfer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(OT::WrapperDataTransfer self) -> WrapperDataTransfer"""
        this = _wrapper.new_WrapperDataTransfer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperDataTransfer
    __del__ = lambda self : None;
WrapperDataTransfer_swigregister = _wrapper.WrapperDataTransfer_swigregister
WrapperDataTransfer_swigregister(WrapperDataTransfer)
WrapperDataTransfer.FILES = _wrapper.cvar.WrapperDataTransfer_FILES
WrapperDataTransfer.PIPE = _wrapper.cvar.WrapperDataTransfer_PIPE
WrapperDataTransfer.ARGUMENTS = _wrapper.cvar.WrapperDataTransfer_ARGUMENTS
WrapperDataTransfer.SOCKET = _wrapper.cvar.WrapperDataTransfer_SOCKET
WrapperDataTransfer.CORBA = _wrapper.cvar.WrapperDataTransfer_CORBA

class WrapperParameter(openturns.common.Object):
    """Proxy of C++ OT::WrapperParameter class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperParameter, name)
    __swig_setmethods__["state_"] = _wrapper.WrapperParameter_state__set
    __swig_getmethods__["state_"] = _wrapper.WrapperParameter_state__get
    if _newclass:state_ = _swig_property(_wrapper.WrapperParameter_state__get, _wrapper.WrapperParameter_state__set)
    __swig_setmethods__["mode_"] = _wrapper.WrapperParameter_mode__set
    __swig_getmethods__["mode_"] = _wrapper.WrapperParameter_mode__get
    if _newclass:mode_ = _swig_property(_wrapper.WrapperParameter_mode__get, _wrapper.WrapperParameter_mode__set)
    __swig_setmethods__["in_"] = _wrapper.WrapperParameter_in__set
    __swig_getmethods__["in_"] = _wrapper.WrapperParameter_in__get
    if _newclass:in_ = _swig_property(_wrapper.WrapperParameter_in__get, _wrapper.WrapperParameter_in__set)
    __swig_setmethods__["out_"] = _wrapper.WrapperParameter_out__set
    __swig_getmethods__["out_"] = _wrapper.WrapperParameter_out__get
    if _newclass:out_ = _swig_property(_wrapper.WrapperParameter_out__get, _wrapper.WrapperParameter_out__set)
    __swig_setmethods__["command_"] = _wrapper.WrapperParameter_command__set
    __swig_getmethods__["command_"] = _wrapper.WrapperParameter_command__get
    if _newclass:command_ = _swig_property(_wrapper.WrapperParameter_command__get, _wrapper.WrapperParameter_command__set)
    __swig_setmethods__["userPrefix_"] = _wrapper.WrapperParameter_userPrefix__set
    __swig_getmethods__["userPrefix_"] = _wrapper.WrapperParameter_userPrefix__get
    if _newclass:userPrefix_ = _swig_property(_wrapper.WrapperParameter_userPrefix__get, _wrapper.WrapperParameter_userPrefix__set)
    def __init__(self): 
        """__init__(OT::WrapperParameter self) -> WrapperParameter"""
        this = _wrapper.new_WrapperParameter()
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(WrapperParameter self) -> OT::String"""
        return _wrapper.WrapperParameter___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperParameter self, OT::String const & offset="") -> OT::String
        __str__(WrapperParameter self) -> OT::String
        """
        return _wrapper.WrapperParameter___str__(self, offset)

    __swig_destroy__ = _wrapper.delete_WrapperParameter
    __del__ = lambda self : None;
WrapperParameter_swigregister = _wrapper.WrapperParameter_swigregister
WrapperParameter_swigregister(WrapperParameter)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WrapperData self) -> OT::String"""
        return _wrapper.WrapperData_getClassName(self)

    def __repr__(self):
        """__repr__(WrapperData self) -> OT::String"""
        return _wrapper.WrapperData___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperData self, OT::String const & offset="") -> OT::String
        __str__(WrapperData self) -> OT::String
        """
        return _wrapper.WrapperData___str__(self, offset)

    def setLibraryPath(self, *args):
        """setLibraryPath(WrapperData self, OT::FileName const & path)"""
        return _wrapper.WrapperData_setLibraryPath(self, *args)

    def getLibraryPath(self):
        """getLibraryPath(WrapperData self) -> OT::FileName"""
        return _wrapper.WrapperData_getLibraryPath(self)

    def setFunctionDescription(self, *args):
        """setFunctionDescription(WrapperData self, WrapperFunctionDescription funcDescription)"""
        return _wrapper.WrapperData_setFunctionDescription(self, *args)

    def getFunctionDescription(self):
        """getFunctionDescription(WrapperData self) -> WrapperFunctionDescription"""
        return _wrapper.WrapperData_getFunctionDescription(self)

    def setGradientDescription(self, *args):
        """setGradientDescription(WrapperData self, WrapperFunctionDescription gradDescription)"""
        return _wrapper.WrapperData_setGradientDescription(self, *args)

    def getGradientDescription(self):
        """getGradientDescription(WrapperData self) -> WrapperFunctionDescription"""
        return _wrapper.WrapperData_getGradientDescription(self)

    def setHessianDescription(self, *args):
        """setHessianDescription(WrapperData self, WrapperFunctionDescription hessDescription)"""
        return _wrapper.WrapperData_setHessianDescription(self, *args)

    def getHessianDescription(self):
        """getHessianDescription(WrapperData self) -> WrapperFunctionDescription"""
        return _wrapper.WrapperData_getHessianDescription(self)

    def setFileList(self, *args):
        """setFileList(WrapperData self, WrapperDataFileCollection fileList)"""
        return _wrapper.WrapperData_setFileList(self, *args)

    def getFileList(self):
        """getFileList(WrapperData self) -> WrapperDataFileCollection"""
        return _wrapper.WrapperData_getFileList(self)

    def getNewFileListForCInterface(self):
        """getNewFileListForCInterface(WrapperData self) -> WrapperFileList"""
        return _wrapper.WrapperData_getNewFileListForCInterface(self)

    def FreeFileListForCInterface(*args):
        """FreeFileListForCInterface(WrapperFileList fileList)"""
        return _wrapper.WrapperData_FreeFileListForCInterface(*args)

    if _newclass:FreeFileListForCInterface = staticmethod(FreeFileListForCInterface)
    __swig_getmethods__["FreeFileListForCInterface"] = lambda x: FreeFileListForCInterface
    def setVariableList(self, *args):
        """setVariableList(WrapperData self, WrapperDataVariableCollection variableList)"""
        return _wrapper.WrapperData_setVariableList(self, *args)

    def getVariableList(self):
        """getVariableList(WrapperData self) -> WrapperDataVariableCollection"""
        return _wrapper.WrapperData_getVariableList(self)

    def getNewVariableListForCInterface(self):
        """getNewVariableListForCInterface(WrapperData self) -> WrapperVariableList"""
        return _wrapper.WrapperData_getNewVariableListForCInterface(self)

    def FreeVariableListForCInterface(*args):
        """FreeVariableListForCInterface(WrapperVariableList variableList)"""
        return _wrapper.WrapperData_FreeVariableListForCInterface(*args)

    if _newclass:FreeVariableListForCInterface = staticmethod(FreeVariableListForCInterface)
    __swig_getmethods__["FreeVariableListForCInterface"] = lambda x: FreeVariableListForCInterface
    def setParameters(self, *args):
        """setParameters(WrapperData self, WrapperParameter parameters)"""
        return _wrapper.WrapperData_setParameters(self, *args)

    def getParameters(self):
        """getParameters(WrapperData self) -> WrapperParameter"""
        return _wrapper.WrapperData_getParameters(self)

    def getNewParametersForCInterface(self):
        """getNewParametersForCInterface(WrapperData self) -> WrapperConfiguration"""
        return _wrapper.WrapperData_getNewParametersForCInterface(self)

    def FreeParametersForCInterface(*args):
        """FreeParametersForCInterface(WrapperConfiguration parameters)"""
        return _wrapper.WrapperData_FreeParametersForCInterface(*args)

    if _newclass:FreeParametersForCInterface = staticmethod(FreeParametersForCInterface)
    __swig_getmethods__["FreeParametersForCInterface"] = lambda x: FreeParametersForCInterface
    def setFrameworkData(self, *args):
        """setFrameworkData(WrapperData self, WrapperFrameworkData framework)"""
        return _wrapper.WrapperData_setFrameworkData(self, *args)

    def getFrameworkData(self):
        """getFrameworkData(WrapperData self) -> WrapperFrameworkData"""
        return _wrapper.WrapperData_getFrameworkData(self)

    def getNewFrameworkForCInterface(self):
        """getNewFrameworkForCInterface(WrapperData self) -> FrameworkData"""
        return _wrapper.WrapperData_getNewFrameworkForCInterface(self)

    def FreeFrameworkForCInterface(*args):
        """FreeFrameworkForCInterface(FrameworkData framework)"""
        return _wrapper.WrapperData_FreeFrameworkForCInterface(*args)

    if _newclass:FreeFrameworkForCInterface = staticmethod(FreeFrameworkForCInterface)
    __swig_getmethods__["FreeFrameworkForCInterface"] = lambda x: FreeFrameworkForCInterface
    def getNewWrapperExchangedDataForCInterface(self):
        """getNewWrapperExchangedDataForCInterface(WrapperData self) -> WrapperExchangedData"""
        return _wrapper.WrapperData_getNewWrapperExchangedDataForCInterface(self)

    def FreeWrapperExchangedDataForCInterface(*args):
        """FreeWrapperExchangedDataForCInterface(WrapperExchangedData exchangedData)"""
        return _wrapper.WrapperData_FreeWrapperExchangedDataForCInterface(*args)

    if _newclass:FreeWrapperExchangedDataForCInterface = staticmethod(FreeWrapperExchangedDataForCInterface)
    __swig_getmethods__["FreeWrapperExchangedDataForCInterface"] = lambda x: FreeWrapperExchangedDataForCInterface
    def isValid(self):
        """isValid(WrapperData self) -> OT::Bool"""
        return _wrapper.WrapperData_isValid(self)

    def CheckSubstitutedVariables(*args):
        """CheckSubstitutedVariables(WrapperDataFile file, WrapperDataVariableCollection variableList)"""
        return _wrapper.WrapperData_CheckSubstitutedVariables(*args)

    if _newclass:CheckSubstitutedVariables = staticmethod(CheckSubstitutedVariables)
    __swig_getmethods__["CheckSubstitutedVariables"] = lambda x: CheckSubstitutedVariables
    def ConvertOpaquePointer(*args):
        """
        ConvertOpaquePointer(void * ptr) -> WrapperExchangedData
        ConvertOpaquePointer(void const * ptr) -> WrapperExchangedData
        """
        return _wrapper.WrapperData_ConvertOpaquePointer(*args)

    if _newclass:ConvertOpaquePointer = staticmethod(ConvertOpaquePointer)
    __swig_getmethods__["ConvertOpaquePointer"] = lambda x: ConvertOpaquePointer
    def __init__(self, *args): 
        """
        __init__(OT::WrapperData self) -> WrapperData
        __init__(OT::WrapperData self, WrapperExchangedData p_exchangedData) -> WrapperData
        __init__(OT::WrapperData self, WrapperData other) -> WrapperData
        """
        this = _wrapper.new_WrapperData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _wrapper.delete_WrapperData
    __del__ = lambda self : None;
WrapperData_swigregister = _wrapper.WrapperData_swigregister
WrapperData_swigregister(WrapperData)

def WrapperData_GetClassName():
  """WrapperData_GetClassName() -> OT::String"""
  return _wrapper.WrapperData_GetClassName()

def WrapperData_FreeFileListForCInterface(*args):
  """WrapperData_FreeFileListForCInterface(WrapperFileList fileList)"""
  return _wrapper.WrapperData_FreeFileListForCInterface(*args)

def WrapperData_FreeVariableListForCInterface(*args):
  """WrapperData_FreeVariableListForCInterface(WrapperVariableList variableList)"""
  return _wrapper.WrapperData_FreeVariableListForCInterface(*args)

def WrapperData_FreeParametersForCInterface(*args):
  """WrapperData_FreeParametersForCInterface(WrapperConfiguration parameters)"""
  return _wrapper.WrapperData_FreeParametersForCInterface(*args)

def WrapperData_FreeFrameworkForCInterface(*args):
  """WrapperData_FreeFrameworkForCInterface(FrameworkData framework)"""
  return _wrapper.WrapperData_FreeFrameworkForCInterface(*args)

def WrapperData_FreeWrapperExchangedDataForCInterface(*args):
  """WrapperData_FreeWrapperExchangedDataForCInterface(WrapperExchangedData exchangedData)"""
  return _wrapper.WrapperData_FreeWrapperExchangedDataForCInterface(*args)

def WrapperData_CheckSubstitutedVariables(*args):
  """WrapperData_CheckSubstitutedVariables(WrapperDataFile file, WrapperDataVariableCollection variableList)"""
  return _wrapper.WrapperData_CheckSubstitutedVariables(*args)

def WrapperData_ConvertOpaquePointer(*args):
  """
    ConvertOpaquePointer(void * ptr) -> WrapperExchangedData
    WrapperData_ConvertOpaquePointer(void const * ptr) -> WrapperExchangedData
    """
  return _wrapper.WrapperData_ConvertOpaquePointer(*args)

class WrapperDataFileCollection(_object):
    """Proxy of C++ OT::Collection<(OT::WrapperDataFile)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataFileCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataFileCollection, name)
    __swig_destroy__ = _wrapper.delete_WrapperDataFileCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(WrapperDataFileCollection self)"""
        return _wrapper.WrapperDataFileCollection_clear(self)

    def __len__(self):
        """__len__(WrapperDataFileCollection self) -> OT::UnsignedLong"""
        return _wrapper.WrapperDataFileCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(WrapperDataFileCollection self, WrapperDataFileCollection rhs) -> OT::Bool"""
        return _wrapper.WrapperDataFileCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(WrapperDataFileCollection self, WrapperDataFile val) -> OT::Bool"""
        return _wrapper.WrapperDataFileCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(WrapperDataFileCollection self, OT::UnsignedLong const i) -> WrapperDataFile"""
        return _wrapper.WrapperDataFileCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(WrapperDataFileCollection self, OT::UnsignedLong const i, WrapperDataFile val)"""
        return _wrapper.WrapperDataFileCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(WrapperDataFileCollection self, OT::UnsignedLong const i)"""
        return _wrapper.WrapperDataFileCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(WrapperDataFileCollection self, OT::UnsignedLong const i) -> WrapperDataFile
        at(WrapperDataFileCollection self, OT::UnsignedLong const i) -> WrapperDataFile
        """
        return _wrapper.WrapperDataFileCollection_at(self, *args)

    def add(self, *args):
        """
        add(WrapperDataFileCollection self, WrapperDataFile elt)
        add(WrapperDataFileCollection self, WrapperDataFileCollection coll)
        """
        return _wrapper.WrapperDataFileCollection_add(self, *args)

    def getSize(self):
        """getSize(WrapperDataFileCollection self) -> OT::UnsignedLong"""
        return _wrapper.WrapperDataFileCollection_getSize(self)

    def resize(self, *args):
        """resize(WrapperDataFileCollection self, OT::UnsignedLong const newSize)"""
        return _wrapper.WrapperDataFileCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(WrapperDataFileCollection self) -> OT::Bool"""
        return _wrapper.WrapperDataFileCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(WrapperDataFileCollection self) -> OT::String"""
        return _wrapper.WrapperDataFileCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperDataFileCollection self, OT::String const & offset="") -> OT::String
        __str__(WrapperDataFileCollection self) -> OT::String
        """
        return _wrapper.WrapperDataFileCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::WrapperDataFile)> self) -> WrapperDataFileCollection
        __init__(OT::Collection<(OT::WrapperDataFile)> self, OT::UnsignedLong const size) -> WrapperDataFileCollection
        __init__(OT::Collection<(OT::WrapperDataFile)> self, OT::UnsignedLong const size, WrapperDataFile value) -> WrapperDataFileCollection
        __init__(OT::Collection<(OT::WrapperDataFile)> self, PyObject * pyObj) -> WrapperDataFileCollection
        __init__(OT::Collection<(OT::WrapperDataFile)> self, WrapperDataFileCollection other) -> WrapperDataFileCollection
        """
        this = _wrapper.new_WrapperDataFileCollection(*args)
        try: self.this.append(this)
        except: self.this = this
WrapperDataFileCollection_swigregister = _wrapper.WrapperDataFileCollection_swigregister
WrapperDataFileCollection_swigregister(WrapperDataFileCollection)

class WrapperDataVariableCollection(_object):
    """Proxy of C++ OT::Collection<(OT::WrapperDataVariable)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariableCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariableCollection, name)
    __swig_destroy__ = _wrapper.delete_WrapperDataVariableCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(WrapperDataVariableCollection self)"""
        return _wrapper.WrapperDataVariableCollection_clear(self)

    def __len__(self):
        """__len__(WrapperDataVariableCollection self) -> OT::UnsignedLong"""
        return _wrapper.WrapperDataVariableCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(WrapperDataVariableCollection self, WrapperDataVariableCollection rhs) -> OT::Bool"""
        return _wrapper.WrapperDataVariableCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(WrapperDataVariableCollection self, WrapperDataVariable val) -> OT::Bool"""
        return _wrapper.WrapperDataVariableCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(WrapperDataVariableCollection self, OT::UnsignedLong const i) -> WrapperDataVariable"""
        return _wrapper.WrapperDataVariableCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(WrapperDataVariableCollection self, OT::UnsignedLong const i, WrapperDataVariable val)"""
        return _wrapper.WrapperDataVariableCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(WrapperDataVariableCollection self, OT::UnsignedLong const i)"""
        return _wrapper.WrapperDataVariableCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(WrapperDataVariableCollection self, OT::UnsignedLong const i) -> WrapperDataVariable
        at(WrapperDataVariableCollection self, OT::UnsignedLong const i) -> WrapperDataVariable
        """
        return _wrapper.WrapperDataVariableCollection_at(self, *args)

    def add(self, *args):
        """
        add(WrapperDataVariableCollection self, WrapperDataVariable elt)
        add(WrapperDataVariableCollection self, WrapperDataVariableCollection coll)
        """
        return _wrapper.WrapperDataVariableCollection_add(self, *args)

    def getSize(self):
        """getSize(WrapperDataVariableCollection self) -> OT::UnsignedLong"""
        return _wrapper.WrapperDataVariableCollection_getSize(self)

    def resize(self, *args):
        """resize(WrapperDataVariableCollection self, OT::UnsignedLong const newSize)"""
        return _wrapper.WrapperDataVariableCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(WrapperDataVariableCollection self) -> OT::Bool"""
        return _wrapper.WrapperDataVariableCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(WrapperDataVariableCollection self) -> OT::String"""
        return _wrapper.WrapperDataVariableCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperDataVariableCollection self, OT::String const & offset="") -> OT::String
        __str__(WrapperDataVariableCollection self) -> OT::String
        """
        return _wrapper.WrapperDataVariableCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::WrapperDataVariable)> self) -> WrapperDataVariableCollection
        __init__(OT::Collection<(OT::WrapperDataVariable)> self, OT::UnsignedLong const size) -> WrapperDataVariableCollection
        __init__(OT::Collection<(OT::WrapperDataVariable)> self, OT::UnsignedLong const size, WrapperDataVariable value) -> WrapperDataVariableCollection
        __init__(OT::Collection<(OT::WrapperDataVariable)> self, PyObject * pyObj) -> WrapperDataVariableCollection
        __init__(OT::Collection<(OT::WrapperDataVariable)> self, WrapperDataVariableCollection other) -> WrapperDataVariableCollection
        """
        this = _wrapper.new_WrapperDataVariableCollection(*args)
        try: self.this.append(this)
        except: self.this = this
WrapperDataVariableCollection_swigregister = _wrapper.WrapperDataVariableCollection_swigregister
WrapperDataVariableCollection_swigregister(WrapperDataVariableCollection)

class WrapperFile(openturns.common.PersistentObject):
    """Proxy of C++ OT::WrapperFile class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFile, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFile, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _wrapper.WrapperFile_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WrapperFile self) -> OT::String"""
        return _wrapper.WrapperFile_getClassName(self)

    def FindWrapperPathByName(*args):
        """FindWrapperPathByName(OT::String const & name) -> OT::FileName"""
        return _wrapper.WrapperFile_FindWrapperPathByName(*args)

    if _newclass:FindWrapperPathByName = staticmethod(FindWrapperPathByName)
    __swig_getmethods__["FindWrapperPathByName"] = lambda x: FindWrapperPathByName
    def FindWrapperByName(*args):
        """FindWrapperByName(OT::String const & name) -> WrapperFile"""
        return _wrapper.WrapperFile_FindWrapperByName(*args)

    if _newclass:FindWrapperByName = staticmethod(FindWrapperByName)
    __swig_getmethods__["FindWrapperByName"] = lambda x: FindWrapperByName
    def BuildWrapperFromStream(*args):
        """BuildWrapperFromStream(OT::String const & xmlStream) -> WrapperFile"""
        return _wrapper.WrapperFile_BuildWrapperFromStream(*args)

    if _newclass:BuildWrapperFromStream = staticmethod(BuildWrapperFromStream)
    __swig_getmethods__["BuildWrapperFromStream"] = lambda x: BuildWrapperFromStream
    def __init__(self, *args): 
        """
        __init__(OT::WrapperFile self) -> WrapperFile
        __init__(OT::WrapperFile self, OT::FileName const & pathToFile) -> WrapperFile
        """
        this = _wrapper.new_WrapperFile(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(WrapperFile self) -> OT::String"""
        return _wrapper.WrapperFile___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WrapperFile self, OT::String const & offset="") -> OT::String
        __str__(WrapperFile self) -> OT::String
        """
        return _wrapper.WrapperFile___str__(self, offset)

    def setDescriptionFilePath(self, *args):
        """setDescriptionFilePath(WrapperFile self, OT::FileName const & path)"""
        return _wrapper.WrapperFile_setDescriptionFilePath(self, *args)

    def getDescriptionFilePath(self):
        """getDescriptionFilePath(WrapperFile self) -> OT::FileName"""
        return _wrapper.WrapperFile_getDescriptionFilePath(self)

    def setWrapperData(self, *args):
        """setWrapperData(WrapperFile self, WrapperData data)"""
        return _wrapper.WrapperFile_setWrapperData(self, *args)

    def getWrapperData(self):
        """getWrapperData(WrapperFile self) -> WrapperData"""
        return _wrapper.WrapperFile_getWrapperData(self)

    def writeFile(self, *args):
        """writeFile(WrapperFile self, OT::FileName const & pathToFile)"""
        return _wrapper.WrapperFile_writeFile(self, *args)

    def toString(self):
        """toString(WrapperFile self) -> OT::String"""
        return _wrapper.WrapperFile_toString(self)

    def getVersion(self):
        """getVersion(WrapperFile self) -> OT::WrapperFile::Version"""
        return _wrapper.WrapperFile_getVersion(self)

    def setVersion(self, *args):
        """setVersion(WrapperFile self, OT::WrapperFile::Version v)"""
        return _wrapper.WrapperFile_setVersion(self, *args)

    __swig_destroy__ = _wrapper.delete_WrapperFile
    __del__ = lambda self : None;
WrapperFile_swigregister = _wrapper.WrapperFile_swigregister
WrapperFile_swigregister(WrapperFile)

def WrapperFile_GetClassName():
  """WrapperFile_GetClassName() -> OT::String"""
  return _wrapper.WrapperFile_GetClassName()

def WrapperFile_FindWrapperPathByName(*args):
  """WrapperFile_FindWrapperPathByName(OT::String const & name) -> OT::FileName"""
  return _wrapper.WrapperFile_FindWrapperPathByName(*args)

def WrapperFile_FindWrapperByName(*args):
  """WrapperFile_FindWrapperByName(OT::String const & name) -> WrapperFile"""
  return _wrapper.WrapperFile_FindWrapperByName(*args)

def WrapperFile_BuildWrapperFromStream(*args):
  """WrapperFile_BuildWrapperFromStream(OT::String const & xmlStream) -> WrapperFile"""
  return _wrapper.WrapperFile_BuildWrapperFromStream(*args)

class UnsignedLongCollection(_object):
    """Proxy of C++ OT::Collection<(OT::UnsignedLong)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnsignedLongCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UnsignedLongCollection, name)
    __swig_destroy__ = _wrapper.delete_UnsignedLongCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(UnsignedLongCollection self)"""
        return _wrapper.UnsignedLongCollection_clear(self)

    def __len__(self):
        """__len__(UnsignedLongCollection self) -> OT::UnsignedLong"""
        return _wrapper.UnsignedLongCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(UnsignedLongCollection self, UnsignedLongCollection rhs) -> OT::Bool"""
        return _wrapper.UnsignedLongCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(UnsignedLongCollection self, unsigned long val) -> OT::Bool"""
        return _wrapper.UnsignedLongCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(UnsignedLongCollection self, OT::UnsignedLong const i) -> unsigned long"""
        return _wrapper.UnsignedLongCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(UnsignedLongCollection self, OT::UnsignedLong const i, unsigned long const & val)"""
        return _wrapper.UnsignedLongCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(UnsignedLongCollection self, OT::UnsignedLong const i)"""
        return _wrapper.UnsignedLongCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(UnsignedLongCollection self, OT::UnsignedLong const i) -> unsigned long
        at(UnsignedLongCollection self, OT::UnsignedLong const i) -> unsigned long const &
        """
        return _wrapper.UnsignedLongCollection_at(self, *args)

    def add(self, *args):
        """
        add(UnsignedLongCollection self, unsigned long const & elt)
        add(UnsignedLongCollection self, UnsignedLongCollection coll)
        """
        return _wrapper.UnsignedLongCollection_add(self, *args)

    def getSize(self):
        """getSize(UnsignedLongCollection self) -> OT::UnsignedLong"""
        return _wrapper.UnsignedLongCollection_getSize(self)

    def resize(self, *args):
        """resize(UnsignedLongCollection self, OT::UnsignedLong const newSize)"""
        return _wrapper.UnsignedLongCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(UnsignedLongCollection self) -> OT::Bool"""
        return _wrapper.UnsignedLongCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(UnsignedLongCollection self) -> OT::String"""
        return _wrapper.UnsignedLongCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(UnsignedLongCollection self, OT::String const & offset="") -> OT::String
        __str__(UnsignedLongCollection self) -> OT::String
        """
        return _wrapper.UnsignedLongCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::UnsignedLong)> self) -> UnsignedLongCollection
        __init__(OT::Collection<(OT::UnsignedLong)> self, OT::UnsignedLong const size) -> UnsignedLongCollection
        __init__(OT::Collection<(OT::UnsignedLong)> self, OT::UnsignedLong const size, unsigned long const & value) -> UnsignedLongCollection
        __init__(OT::Collection<(OT::UnsignedLong)> self, PyObject * pyObj) -> UnsignedLongCollection
        __init__(OT::Collection<(OT::UnsignedLong)> self, UnsignedLongCollection other) -> UnsignedLongCollection
        """
        this = _wrapper.new_UnsignedLongCollection(*args)
        try: self.this.append(this)
        except: self.this = this
UnsignedLongCollection_swigregister = _wrapper.UnsignedLongCollection_swigregister
UnsignedLongCollection_swigregister(UnsignedLongCollection)

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