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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

import _fmippex

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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



def new_double_pointer():
    return _fmippex.new_double_pointer()

def copy_double_pointer(value):
    return _fmippex.copy_double_pointer(value)

def delete_double_pointer(obj):
    return _fmippex.delete_double_pointer(obj)

def double_pointer_assign(obj, value):
    return _fmippex.double_pointer_assign(obj, value)

def double_pointer_value(obj):
    return _fmippex.double_pointer_value(obj)

def new_int_pointer():
    return _fmippex.new_int_pointer()

def copy_int_pointer(value):
    return _fmippex.copy_int_pointer(value)

def delete_int_pointer(obj):
    return _fmippex.delete_int_pointer(obj)

def int_pointer_assign(obj, value):
    return _fmippex.int_pointer_assign(obj, value)

def int_pointer_value(obj):
    return _fmippex.int_pointer_value(obj)

def new_string_pointer():
    return _fmippex.new_string_pointer()

def copy_string_pointer(value):
    return _fmippex.copy_string_pointer(value)

def delete_string_pointer(obj):
    return _fmippex.delete_string_pointer(obj)

def string_pointer_assign(obj, value):
    return _fmippex.string_pointer_assign(obj, value)

def string_pointer_value(obj):
    return _fmippex.string_pointer_value(obj)

def new_bool_pointer():
    return _fmippex.new_bool_pointer()

def copy_bool_pointer(value):
    return _fmippex.copy_bool_pointer(value)

def delete_bool_pointer(obj):
    return _fmippex.delete_bool_pointer(obj)

def bool_pointer_assign(obj, value):
    return _fmippex.bool_pointer_assign(obj, value)

def bool_pointer_value(obj):
    return _fmippex.bool_pointer_value(obj)

def new_double_array(nelements):
    return _fmippex.new_double_array(nelements)

def delete_double_array(ary):
    return _fmippex.delete_double_array(ary)

def double_array_getitem(ary, index):
    return _fmippex.double_array_getitem(ary, index)

def double_array_setitem(ary, index, value):
    return _fmippex.double_array_setitem(ary, index, value)

def new_int_array(nelements):
    return _fmippex.new_int_array(nelements)

def delete_int_array(ary):
    return _fmippex.delete_int_array(ary)

def int_array_getitem(ary, index):
    return _fmippex.int_array_getitem(ary, index)

def int_array_setitem(ary, index, value):
    return _fmippex.int_array_setitem(ary, index, value)

def new_string_array(nelements):
    return _fmippex.new_string_array(nelements)

def delete_string_array(ary):
    return _fmippex.delete_string_array(ary)

def string_array_getitem(ary, index):
    return _fmippex.string_array_getitem(ary, index)

def string_array_setitem(ary, index, value):
    return _fmippex.string_array_setitem(ary, index, value)

def new_bool_array(nelements):
    return _fmippex.new_bool_array(nelements)

def delete_bool_array(ary):
    return _fmippex.delete_bool_array(ary)

def bool_array_getitem(ary, index):
    return _fmippex.bool_array_getitem(ary, index)

def bool_array_setitem(ary, index, value):
    return _fmippex.bool_array_setitem(ary, index, value)
fmiModelTypesPlatform = _fmippex.fmiModelTypesPlatform

fmiPlatform = _fmippex.fmiPlatform

fmiTrue = _fmippex.fmiTrue

fmiFalse = _fmippex.fmiFalse

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterationConverged = property(_fmippex.fmiEventInfo_iterationConverged_get, _fmippex.fmiEventInfo_iterationConverged_set, doc=r"""iterationConverged""")
    stateValueReferencesChanged = property(_fmippex.fmiEventInfo_stateValueReferencesChanged_get, _fmippex.fmiEventInfo_stateValueReferencesChanged_set, doc=r"""stateValueReferencesChanged""")
    stateValuesChanged = property(_fmippex.fmiEventInfo_stateValuesChanged_get, _fmippex.fmiEventInfo_stateValuesChanged_set, doc=r"""stateValuesChanged""")
    terminateSimulation = property(_fmippex.fmiEventInfo_terminateSimulation_get, _fmippex.fmiEventInfo_terminateSimulation_set, doc=r"""terminateSimulation""")
    upcomingTimeEvent = property(_fmippex.fmiEventInfo_upcomingTimeEvent_get, _fmippex.fmiEventInfo_upcomingTimeEvent_set, doc=r"""upcomingTimeEvent""")
    nextEventTime = property(_fmippex.fmiEventInfo_nextEventTime_get, _fmippex.fmiEventInfo_nextEventTime_set, doc=r"""nextEventTime""")

    def __init__(self):
        r"""__init__(self) -> fmiEventInfo"""
        _fmippex.fmiEventInfo_swiginit(self, _fmippex.new_fmiEventInfo())
    __swig_destroy__ = _fmippex.delete_fmiEventInfo

# Register fmiEventInfo in _fmippex:
_fmippex.fmiEventInfo_swigregister(fmiEventInfo)

fmiOK = _fmippex.fmiOK

fmiWarning = _fmippex.fmiWarning

fmiDiscard = _fmippex.fmiDiscard

fmiError = _fmippex.fmiError

fmiFatal = _fmippex.fmiFatal

fmiPending = _fmippex.fmiPending

fmiDoStepStatus = _fmippex.fmiDoStepStatus

fmiPendingStatus = _fmippex.fmiPendingStatus

fmiLastSuccessfulTime = _fmippex.fmiLastSuccessfulTime

fmi2TypesPlatform = _fmippex.fmi2TypesPlatform

fmi2True = _fmippex.fmi2True

fmi2False = _fmippex.fmi2False

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    newDiscreteStatesNeeded = property(_fmippex.fmi2EventInfo_newDiscreteStatesNeeded_get, _fmippex.fmi2EventInfo_newDiscreteStatesNeeded_set, doc=r"""newDiscreteStatesNeeded""")
    terminateSimulation = property(_fmippex.fmi2EventInfo_terminateSimulation_get, _fmippex.fmi2EventInfo_terminateSimulation_set, doc=r"""terminateSimulation""")
    nominalsOfContinuousStatesChanged = property(_fmippex.fmi2EventInfo_nominalsOfContinuousStatesChanged_get, _fmippex.fmi2EventInfo_nominalsOfContinuousStatesChanged_set, doc=r"""nominalsOfContinuousStatesChanged""")
    valuesOfContinuousStatesChanged = property(_fmippex.fmi2EventInfo_valuesOfContinuousStatesChanged_get, _fmippex.fmi2EventInfo_valuesOfContinuousStatesChanged_set, doc=r"""valuesOfContinuousStatesChanged""")
    nextEventTimeDefined = property(_fmippex.fmi2EventInfo_nextEventTimeDefined_get, _fmippex.fmi2EventInfo_nextEventTimeDefined_set, doc=r"""nextEventTimeDefined""")
    nextEventTime = property(_fmippex.fmi2EventInfo_nextEventTime_get, _fmippex.fmi2EventInfo_nextEventTime_set, doc=r"""nextEventTime""")

    def __init__(self):
        r"""__init__(self) -> fmi2EventInfo"""
        _fmippex.fmi2EventInfo_swiginit(self, _fmippex.new_fmi2EventInfo())
    __swig_destroy__ = _fmippex.delete_fmi2EventInfo

# Register fmi2EventInfo in _fmippex:
_fmippex.fmi2EventInfo_swigregister(fmi2EventInfo)

fmi2OK = _fmippex.fmi2OK

fmi2Warning = _fmippex.fmi2Warning

fmi2Discard = _fmippex.fmi2Discard

fmi2Error = _fmippex.fmi2Error

fmi2Fatal = _fmippex.fmi2Fatal

fmi2Pending = _fmippex.fmi2Pending

fmi2ModelExchange = _fmippex.fmi2ModelExchange

fmi2CoSimulation = _fmippex.fmi2CoSimulation

fmi2DoStepStatus = _fmippex.fmi2DoStepStatus

fmi2PendingStatus = _fmippex.fmi2PendingStatus

fmi2LastSuccessfulTime = _fmippex.fmi2LastSuccessfulTime

fmi2Terminated = _fmippex.fmi2Terminated

fmippTypeReal = _fmippex.fmippTypeReal

fmippTypeInteger = _fmippex.fmippTypeInteger

fmippTypeBoolean = _fmippex.fmippTypeBoolean

fmippTypeString = _fmippex.fmippTypeString

fmippTypeUnknown = _fmippex.fmippTypeUnknown

fmippOK = _fmippex.fmippOK

fmippWarning = _fmippex.fmippWarning

fmippDiscard = _fmippex.fmippDiscard

fmippError = _fmippex.fmippError

fmippFatal = _fmippex.fmippFatal

fmippTrue = _fmippex.fmippTrue

fmippFalse = _fmippex.fmippFalse

fmippClockActive = _fmippex.fmippClockActive

fmippClockInactive = _fmippex.fmippClockInactive

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

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

    def __init__(self):
        r"""__init__(self) -> FMIComponentBackEnd"""
        _fmippex.FMIComponentBackEnd_swiginit(self, _fmippex.new_FMIComponentBackEnd())
    __swig_destroy__ = _fmippex.delete_FMIComponentBackEnd

    def startInitialization(self):
        r"""startInitialization(self) -> fmippStatus"""
        return _fmippex.FMIComponentBackEnd_startInitialization(self)

    def endInitialization(self):
        r"""endInitialization(self) -> fmippStatus"""
        return _fmippex.FMIComponentBackEnd_endInitialization(self)

    def initializeRealParameters(self, *args):
        r"""
        initializeRealParameters(self, names, params) -> fmippStatus
        initializeRealParameters(self, names, params, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeRealParameters(self, *args)

    def initializeIntegerParameters(self, *args):
        r"""
        initializeIntegerParameters(self, names, params) -> fmippStatus
        initializeIntegerParameters(self, names, params, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeIntegerParameters(self, *args)

    def initializeBooleanParameters(self, *args):
        r"""
        initializeBooleanParameters(self, names, params) -> fmippStatus
        initializeBooleanParameters(self, names, params, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeBooleanParameters(self, *args)

    def initializeStringParameters(self, *args):
        r"""
        initializeStringParameters(self, names, params) -> fmippStatus
        initializeStringParameters(self, names, params, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeStringParameters(self, *args)

    def initializeRealInputs(self, *args):
        r"""
        initializeRealInputs(self, names, inputs) -> fmippStatus
        initializeRealInputs(self, names, inputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeRealInputs(self, *args)

    def initializeIntegerInputs(self, *args):
        r"""
        initializeIntegerInputs(self, names, inputs) -> fmippStatus
        initializeIntegerInputs(self, names, inputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeIntegerInputs(self, *args)

    def initializeBooleanInputs(self, *args):
        r"""
        initializeBooleanInputs(self, names, inputs) -> fmippStatus
        initializeBooleanInputs(self, names, inputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeBooleanInputs(self, *args)

    def initializeStringInputs(self, *args):
        r"""
        initializeStringInputs(self, names, inputs) -> fmippStatus
        initializeStringInputs(self, names, inputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeStringInputs(self, *args)

    def initializeRealOutputs(self, *args):
        r"""
        initializeRealOutputs(self, names, outputs) -> fmippStatus
        initializeRealOutputs(self, names, outputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeRealOutputs(self, *args)

    def initializeIntegerOutputs(self, *args):
        r"""
        initializeIntegerOutputs(self, names, outputs) -> fmippStatus
        initializeIntegerOutputs(self, names, outputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeIntegerOutputs(self, *args)

    def initializeBooleanOutputs(self, *args):
        r"""
        initializeBooleanOutputs(self, names, outputs) -> fmippStatus
        initializeBooleanOutputs(self, names, outputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeBooleanOutputs(self, *args)

    def initializeStringOutputs(self, *args):
        r"""
        initializeStringOutputs(self, names, outputs) -> fmippStatus
        initializeStringOutputs(self, names, outputs, n) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_initializeStringOutputs(self, *args)

    def waitForMaster(self):
        r"""waitForMaster(self)"""
        return _fmippex.FMIComponentBackEnd_waitForMaster(self)

    def signalToMaster(self):
        r"""signalToMaster(self)"""
        return _fmippex.FMIComponentBackEnd_signalToMaster(self)

    def getRealParameters(self, *args):
        r"""
        getRealParameters(self, parameters) -> fmippStatus
        getRealParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getRealParameters(self, *args)

    def getIntegerParameters(self, *args):
        r"""
        getIntegerParameters(self, parameters) -> fmippStatus
        getIntegerParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getIntegerParameters(self, *args)

    def getBooleanParameters(self, *args):
        r"""
        getBooleanParameters(self, parameters) -> fmippStatus
        getBooleanParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getBooleanParameters(self, *args)

    def getStringParameters(self, *args):
        r"""
        getStringParameters(self, parameters) -> fmippStatus
        getStringParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getStringParameters(self, *args)

    def setRealParameters(self, *args):
        r"""
        setRealParameters(self, parameters) -> fmippStatus
        setRealParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setRealParameters(self, *args)

    def setIntegerParameters(self, *args):
        r"""
        setIntegerParameters(self, parameters) -> fmippStatus
        setIntegerParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setIntegerParameters(self, *args)

    def setBooleanParameters(self, *args):
        r"""
        setBooleanParameters(self, parameters) -> fmippStatus
        setBooleanParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setBooleanParameters(self, *args)

    def setStringParameters(self, *args):
        r"""
        setStringParameters(self, parameters) -> fmippStatus
        setStringParameters(self, parameters, nParameters) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setStringParameters(self, *args)

    def getRealInputs(self, *args):
        r"""
        getRealInputs(self, inputs) -> fmippStatus
        getRealInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getRealInputs(self, *args)

    def getIntegerInputs(self, *args):
        r"""
        getIntegerInputs(self, inputs) -> fmippStatus
        getIntegerInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getIntegerInputs(self, *args)

    def getBooleanInputs(self, *args):
        r"""
        getBooleanInputs(self, inputs) -> fmippStatus
        getBooleanInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getBooleanInputs(self, *args)

    def getStringInputs(self, *args):
        r"""
        getStringInputs(self, inputs) -> fmippStatus
        getStringInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_getStringInputs(self, *args)

    def resetRealInputs(self, *args):
        r"""
        resetRealInputs(self, inputs) -> fmippStatus
        resetRealInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_resetRealInputs(self, *args)

    def resetIntegerInputs(self, *args):
        r"""
        resetIntegerInputs(self, inputs) -> fmippStatus
        resetIntegerInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_resetIntegerInputs(self, *args)

    def resetBooleanInputs(self, *args):
        r"""
        resetBooleanInputs(self, inputs) -> fmippStatus
        resetBooleanInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_resetBooleanInputs(self, *args)

    def resetStringInputs(self, *args):
        r"""
        resetStringInputs(self, inputs) -> fmippStatus
        resetStringInputs(self, inputs, nInputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_resetStringInputs(self, *args)

    def setRealOutputs(self, *args):
        r"""
        setRealOutputs(self, outputs) -> fmippStatus
        setRealOutputs(self, outputs, nOutputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setRealOutputs(self, *args)

    def setIntegerOutputs(self, *args):
        r"""
        setIntegerOutputs(self, outputs) -> fmippStatus
        setIntegerOutputs(self, outputs, nOutputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setIntegerOutputs(self, *args)

    def setBooleanOutputs(self, *args):
        r"""
        setBooleanOutputs(self, outputs) -> fmippStatus
        setBooleanOutputs(self, outputs, nOutputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setBooleanOutputs(self, *args)

    def setStringOutputs(self, *args):
        r"""
        setStringOutputs(self, outputs) -> fmippStatus
        setStringOutputs(self, outputs, nOutputs) -> fmippStatus
        """
        return _fmippex.FMIComponentBackEnd_setStringOutputs(self, *args)

    def enforceTimeStep(self, delta):
        r"""enforceTimeStep(self, delta)"""
        return _fmippex.FMIComponentBackEnd_enforceTimeStep(self, delta)

    def rejectStep(self):
        r"""rejectStep(self)"""
        return _fmippex.FMIComponentBackEnd_rejectStep(self)

    def logger(self, status, category, msg):
        r"""logger(self, status, category, msg)"""
        return _fmippex.FMIComponentBackEnd_logger(self, status, category, msg)

    def getCurrentCommunicationPoint(self):
        r"""getCurrentCommunicationPoint(self) -> fmippReal const &"""
        return _fmippex.FMIComponentBackEnd_getCurrentCommunicationPoint(self)

    def getCommunicationStepSize(self):
        r"""getCommunicationStepSize(self) -> fmippReal const &"""
        return _fmippex.FMIComponentBackEnd_getCommunicationStepSize(self)

    def getStopTime(self):
        r"""getStopTime(self) -> fmippReal const &"""
        return _fmippex.FMIComponentBackEnd_getStopTime(self)

    def getStopTimeDefined(self):
        r"""getStopTimeDefined(self) -> bool const &"""
        return _fmippex.FMIComponentBackEnd_getStopTimeDefined(self)

    def getLogFileName(self):
        r"""getLogFileName(self) -> fmippString"""
        return _fmippex.FMIComponentBackEnd_getLogFileName(self)

    def loggingOn(self):
        r"""loggingOn(self) -> bool"""
        return _fmippex.FMIComponentBackEnd_loggingOn(self)

    def getRealInputNames(self, names):
        r"""getRealInputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getRealInputNames(self, names)

    def getIntegerInputNames(self, names):
        r"""getIntegerInputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getIntegerInputNames(self, names)

    def getBooleanInputNames(self, names):
        r"""getBooleanInputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getBooleanInputNames(self, names)

    def getStringInputNames(self, names):
        r"""getStringInputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getStringInputNames(self, names)

    def getRealOutputNames(self, names):
        r"""getRealOutputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getRealOutputNames(self, names)

    def getIntegerOutputNames(self, names):
        r"""getIntegerOutputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getIntegerOutputNames(self, names)

    def getBooleanOutputNames(self, names):
        r"""getBooleanOutputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getBooleanOutputNames(self, names)

    def getStringOutputNames(self, names):
        r"""getStringOutputNames(self, names)"""
        return _fmippex.FMIComponentBackEnd_getStringOutputNames(self, names)

# Register FMIComponentBackEnd in _fmippex:
_fmippex.FMIComponentBackEnd_swigregister(FMIComponentBackEnd)



