uaprovider_demo_call.c

/*****************************************************************************
 *
 * Copyright (c) 2006-2015 Unified Automation GmbH. All rights reserved.
 *
 * Software License Agreement ("SLA") Version 2.5
 *
 * Unless explicitly acquired and licensed from Licensor under another
 * license, the contents of this file are subject to the Software License
 * Agreement ("SLA") Version 2.5, or subsequent versions as allowed by the
 * SLA, and You may not copy or use this file in either source code or
 * executable form, except in compliance with the terms and conditions of
 * the SLA.
 *
 * All software distributed under the SLA is provided strictly on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
 * AND LICENSOR HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT, OR NON-INFRINGEMENT. See the SLA for specific
 * language governing rights and limitations under the SLA.
 *
 * The complete license agreement can be found here:
 * http://unifiedautomation.com/License/SLA/2.5/
 *
 * Project: OPC Ansi C DemoProvider for namespace
 *          'http://www.unifiedautomation.com/DemoServer/'
 *
 ****************************************************************************/

#include <uaserver_config.h>

#include <opcua_platformdefs.h>
#include <opcua_statuscodes.h>

#include <uabase_p_atomic.h>
#include <uaserver_basenode.h>
#include <uaserver_utilities.h>
#include <uaserver_call.h>

#include "uaprovider_demo_helper.h"
#include "uaprovider_demo_types_1.h"

#include "uaprovider_demo_boilertype_methods.h"
#include "uaprovider_demo_methods_1.h"

#include "uaprovider_demo_identifiers_1.h"


OPCUA_BEGIN_EXTERN_C

#define OPCUA_ARRAY_FROM_VARIANT(type, a_pVariant, a_pNoOfValues, a_ppValues) \
{ \
    OpcUa_Int32 i; \
    OpcUa_##type *pValue; \
    OpcUa_##type *pValues; \
\
    OpcUa_ReturnErrorIfArgumentNull(a_pVariant); \
    OpcUa_ReturnErrorIfArgumentNull(a_pNoOfValues); \
    OpcUa_ReturnErrorIfArgumentNull(a_ppValues); \
\
    if (!a_pVariant || a_pVariant->ArrayType != OpcUa_VariantArrayType_Array || a_pVariant->Datatype != OpcUaType_ExtensionObject \
        || (a_pVariant->Value.Array.Length && !a_pVariant->Value.Array.Value.ExtensionObjectArray) ) \
    { \
        return OpcUa_BadInvalidArgument; \
    } \
    for (i=0; i<a_pVariant->Value.Array.Length; i++) \
    { \
        if (a_pVariant->Value.Array.Value.ExtensionObjectArray[i].Encoding != OpcUa_ExtensionObjectEncoding_EncodeableObject \
            || !a_pVariant->Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type \
            || a_pVariant->Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type->TypeId != OpcUaId_##type) \
        { \
            return OpcUa_BadInvalidArgument; \
        } \
    } \
\
    *a_pNoOfValues = a_pVariant->Value.Array.Length; \
    pValues = (OpcUa_##type*) OpcUa_Alloc((*a_pNoOfValues) * sizeof(OpcUa_##type)); \
    OpcUa_ReturnErrorIfAllocFailed(pValues); \
    for (i=0; i<*a_pNoOfValues; i++) \
    { \
        OpcUa_##type##_Initialize(&pValues[i]); \
        pValue = (OpcUa_##type*) a_pVariant->Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object; \
        pValues[i] = *pValue; \
    } \
    *a_ppValues = pValues; \
}

#define OPCUA_ARRAY_TO_VARIANT(type, a_pNoOfValues, a_ppValues, a_pVariant) \
{ \
    OpcUa_Int32 i; \
    OpcUa_##type *pValue; \
\
    OpcUa_ReturnErrorIfArgumentNull(a_pNoOfValues); \
    OpcUa_ReturnErrorIfArgumentNull(a_ppValues); \
    OpcUa_ReturnErrorIfArgumentNull(*a_ppValues); \
    OpcUa_ReturnErrorIfArgumentNull(a_pVariant); \
\
    OpcUa_Variant_Initialize(a_pVariant); \
    a_pVariant->Datatype = OpcUaType_ExtensionObject; \
    a_pVariant->ArrayType = OpcUa_VariantArrayType_Array; \
    a_pVariant->Value.Array.Length = *a_pNoOfValues; \
\
    if (*a_pNoOfValues > 0) \
    { \
        a_pVariant->Value.Array.Value.ExtensionObjectArray = (OpcUa_ExtensionObject*) OpcUa_Alloc(*a_pNoOfValues * sizeof (OpcUa_ExtensionObject)); \
        OpcUa_ReturnErrorIfAllocFailed(a_pVariant->Value.Array.Value.ExtensionObjectArray); \
        for (i=0; i<*a_pNoOfValues; i++) \
        { \
            OpcUa_ExtensionObject_Initialize(&a_pVariant->Value.Array.Value.ExtensionObjectArray[i]); \
            OpcUa_EncodeableObject_CreateExtension(&OpcUa_##type##_EncodeableType, &a_pVariant->Value.Array.Value.ExtensionObjectArray[i], (OpcUa_Void**)&pValue); \
            OpcUa_MemCpy(pValue, sizeof (OpcUa_##type), (*a_ppValues)+i, sizeof(OpcUa_##type)); \
        } \
        OpcUa_Free(*a_ppValues); \
        *a_pNoOfValues = 0; \
        *a_ppValues = OpcUa_Null; \
    } \
}

OpcUa_StatusCode UaProvider_Demo_BoilerType_CallFill(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 1)
    {
        /* Declaration of method arguments */
        OpcUa_Double SetPoint;

        /* Check DataTypes of InputArguments */
        OpcUa_Variant *pArgument0 = &a_pRequest->InputArguments[0];
        if (!pArgument0 || pArgument0->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument0->Datatype != OpcUaType_Double)
        {
            return OpcUa_BadInvalidArgument;
        }

        /* Variables from InputArguments */
        SetPoint = pArgument0->Value.Double;
        ret = UaProvider_Demo_BoilerType_Fill(a_pCallContext, &a_pRequest->ObjectId, SetPoint);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_BoilerType_CallHeat(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 1)
    {
        /* Declaration of method arguments */
        OpcUa_Double Setpoint;

        /* Check DataTypes of InputArguments */
        OpcUa_Variant *pArgument0 = &a_pRequest->InputArguments[0];
        if (!pArgument0 || pArgument0->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument0->Datatype != OpcUaType_Double)
        {
            return OpcUa_BadInvalidArgument;
        }

        /* Variables from InputArguments */
        Setpoint = pArgument0->Value.Double;
        ret = UaProvider_Demo_BoilerType_Heat(a_pCallContext, &a_pRequest->ObjectId, Setpoint);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Has3ForwardReferences2_CallMethod1(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_Has3ForwardReferences2_Method1(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Has3ForwardReferences2_CallMethod2(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_Has3ForwardReferences2_Method2(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Has3ForwardReferences2_CallMethod3(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_Has3ForwardReferences2_Method3(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Has3ForwardReferences5_CallReferencedNode3(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_Has3ForwardReferences5_ReferencedNode3(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_NodeClasses_CallMethod(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_NodeClasses_Method(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_DynamicNodes_CallCreateDynamicNode(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_DynamicNodes_CreateDynamicNode(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_DynamicNodes_CallDeleteDynamicNode(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_DynamicNodes_DeleteDynamicNode(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_History_CallStartLogging(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_History_StartLogging(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_History_CallStopLogging(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_History_StopLogging(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Method_CallMultiply(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 2)
    {
        /* Declaration of method arguments */
        OpcUa_Double a;
        OpcUa_Double b;
        OpcUa_Double result;

        /* Check DataTypes of InputArguments */
        OpcUa_Variant *pArgument0 = &a_pRequest->InputArguments[0];
        OpcUa_Variant *pArgument1 = &a_pRequest->InputArguments[1];
        if (!pArgument0 || pArgument0->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument0->Datatype != OpcUaType_Double
             || !pArgument1 || pArgument1->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument1->Datatype != OpcUaType_Double)
        {
            return OpcUa_BadInvalidArgument;
        }

        /* Variables from InputArguments */
        a = pArgument0->Value.Double;
        b = pArgument1->Value.Double;
        ret = UaProvider_Demo_Method_Multiply(a_pCallContext, &a_pRequest->ObjectId, a, b, &result);
        a_pResult->StatusCode = ret;
        if (OpcUa_IsNotBad(ret))
        {
            /* Fill result */
            a_pResult->NoOfOutputArguments = 1;
            a_pResult->OutputArguments = (OpcUa_Variant *)OpcUa_Alloc(1 * sizeof(OpcUa_Variant));
            if ( a_pResult->OutputArguments )
            {
                OpcUa_Variant_Initialize(&a_pResult->OutputArguments[0]);
                a_pResult->OutputArguments[0].Datatype = OpcUaType_Double;
                a_pResult->OutputArguments[0].Value.Double = result;
            }
        }
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Method_CallVectorAdd(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 2)
    {
        /* Declaration of method arguments */
        Demo_Vector *v1;
        Demo_Vector *v2;
        Demo_Vector result;
        Demo_Vector *presult;

        /* Check DataTypes of InputArguments */
        OpcUa_Variant *pArgument0 = &a_pRequest->InputArguments[0];
        OpcUa_Variant *pArgument1 = &a_pRequest->InputArguments[1];

        Demo_Vector_Initialize(&result);

        if (!pArgument0 || pArgument0->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument0->Datatype != OpcUaType_ExtensionObject
                || !pArgument0->Value.ExtensionObject
                || pArgument0->Value.ExtensionObject->Encoding != OpcUa_ExtensionObjectEncoding_EncodeableObject
                || !pArgument0->Value.ExtensionObject->Body.EncodeableObject.Type
                || pArgument0->Value.ExtensionObject->Body.EncodeableObject.Type->TypeId != Demo_VectorId
             || !pArgument1 || pArgument1->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument1->Datatype != OpcUaType_ExtensionObject
                || !pArgument1->Value.ExtensionObject
                || pArgument1->Value.ExtensionObject->Encoding != OpcUa_ExtensionObjectEncoding_EncodeableObject
                || !pArgument1->Value.ExtensionObject->Body.EncodeableObject.Type
                || pArgument1->Value.ExtensionObject->Body.EncodeableObject.Type->TypeId != Demo_VectorId)
        {
            return OpcUa_BadInvalidArgument;
        }

        /* Variables from InputArguments */
        v1 = pArgument0->Value.ExtensionObject->Body.EncodeableObject.Object;
        v2 = pArgument1->Value.ExtensionObject->Body.EncodeableObject.Object;
        ret = UaProvider_Demo_Method_VectorAdd(a_pCallContext, &a_pRequest->ObjectId, v1, v2, &result);
        a_pResult->StatusCode = ret;
        if (OpcUa_IsNotBad(ret))
        {
            /* Fill result */
            a_pResult->NoOfOutputArguments = 1;
            a_pResult->OutputArguments = (OpcUa_Variant *)OpcUa_Alloc(1 * sizeof(OpcUa_Variant));
            if ( a_pResult->OutputArguments )
            {
                OpcUa_Variant_Initialize(&a_pResult->OutputArguments[0]);
                a_pResult->OutputArguments[0].Datatype = OpcUaType_ExtensionObject;
                a_pResult->OutputArguments[0].Value.ExtensionObject = (OpcUa_ExtensionObject*)OpcUa_Alloc(sizeof(OpcUa_ExtensionObject));
                OpcUa_ExtensionObject_Initialize(a_pResult->OutputArguments[0].Value.ExtensionObject);
                OpcUa_EncodeableObject_CreateExtension(&Demo_Vector_EncodeableType, a_pResult->OutputArguments[0].Value.ExtensionObject, (OpcUa_Void**)&presult);
                *presult = result;
                Demo_Vector_Initialize(&result);
            }
        }
        Demo_Vector_Clear(&result);
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Demo_CallSetSimulationSpeed(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 1)
    {
        /* Declaration of method arguments */
        OpcUa_UInt32 speed;

        /* Check DataTypes of InputArguments */
        OpcUa_Variant *pArgument0 = &a_pRequest->InputArguments[0];
        if (!pArgument0 || pArgument0->ArrayType != OpcUa_VariantArrayType_Scalar || pArgument0->Datatype != OpcUaType_UInt32)
        {
            return OpcUa_BadInvalidArgument;
        }

        /* Variables from InputArguments */
        speed = pArgument0->Value.UInt32;
        ret = UaProvider_Demo_Demo_SetSimulationSpeed(a_pCallContext, &a_pRequest->ObjectId, speed);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Demo_CallStartSimulation(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_Demo_StartSimulation(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

OpcUa_StatusCode UaProvider_Demo_Demo_CallStopSimulation(UaServer_ProviderCallContext* a_pCallContext, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    OpcUa_StatusCode ret = OpcUa_Good;
    /* Check number of InputArguments */
    if (a_pRequest->NoOfInputArguments == 0)
    {
        ret = UaProvider_Demo_Demo_StopSimulation(a_pCallContext, &a_pRequest->ObjectId);
        a_pResult->StatusCode = ret;
    }
    else
    {
        /* Wrong number of InputArguments */
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }
    return ret;
}

/* ****************** End Namespace 1 ********************** */

#if UASERVER_SUPPORT_EVENTS
OpcUa_StatusCode UaProvider_Demo_CallAcknowledge(UaServer_Event *a_pEvent, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    if (a_pRequest->NoOfInputArguments == 2)
    {
        a_pResult->StatusCode = OpcUa_Good;

        a_pResult->NoOfInputArgumentResults = 2;
        a_pResult->InputArgumentResults = (OpcUa_StatusCode*)OpcUa_Alloc(a_pResult->NoOfInputArgumentResults * sizeof(OpcUa_StatusCode));
        OpcUa_MemSet(a_pResult->InputArgumentResults, 0, a_pResult->NoOfInputArgumentResults * sizeof(OpcUa_StatusCode));

        if (a_pRequest->InputArguments[0].Datatype != OpcUaType_ByteString
            || a_pRequest->InputArguments[0].ArrayType != OpcUa_VariantArrayType_Scalar)
        {
            a_pResult->InputArgumentResults[0] = OpcUa_BadTypeMismatch;
            a_pResult->StatusCode = OpcUa_BadTypeMismatch;
        }
        if (a_pRequest->InputArguments[1].Datatype != OpcUaType_LocalizedText
            || a_pRequest->InputArguments[1].ArrayType != OpcUa_VariantArrayType_Scalar)
        {
            a_pResult->InputArgumentResults[1] = OpcUa_BadTypeMismatch;
            a_pResult->StatusCode = OpcUa_BadTypeMismatch;
        }

        /* check EventId */
        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_ByteString *pEventId = UaServer_Events_GetEventId(a_pEvent);
            if (OpcUa_ByteString_Compare(pEventId, &a_pRequest->InputArguments[0].Value.ByteString) != 0)
            {
                a_pResult->StatusCode = OpcUa_BadEventIdUnknown;
            }
        }

        /* check AckedState */
        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_Variant *pAckedState = (OpcUa_Variant*)UaBase_Vector_Get(&a_pEvent->EventFields, AcknowledgeableConditionTypeField_AckedState_Id);
            a_pResult->StatusCode = OpcUa_BadConditionBranchAlreadyAcked;

            if (pAckedState != OpcUa_Null
                && pAckedState->Datatype == OpcUaType_Boolean
                && pAckedState->ArrayType == OpcUa_VariantArrayType_Scalar
                && pAckedState->Value.Boolean == OpcUa_False)
            {
                a_pResult->StatusCode = OpcUa_Good;
            }
        }

        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_Variant value;
            OpcUa_NodeId *pSourceNode;
            OpcUa_Variant_Initialize(&value);

            value.Datatype = OpcUaType_LocalizedText;
            value.Value.LocalizedText = (OpcUa_LocalizedText*)OpcUa_Alloc(sizeof(OpcUa_LocalizedText));
            OpcUa_LocalizedText_Initialize(value.Value.LocalizedText);
            OpcUa_String_StrnCat(&value.Value.LocalizedText->Text, OpcUa_String_FromCString("Acknowledged"), OPCUA_STRING_LENDONTCARE);
            UaServer_Events_SetEventField(a_pEvent, AcknowledgeableConditionTypeField_AckedState, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_Boolean;
            value.Value.Boolean = OpcUa_True;
            UaServer_Events_SetEventField(a_pEvent, AcknowledgeableConditionTypeField_AckedState_Id, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_DateTime;
            value.Value.DateTime = OpcUa_DateTime_UtcNow();
            UaServer_Events_SetEventField(a_pEvent, AcknowledgeableConditionTypeField_AckedState_TransitionTime, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_LocalizedText;
            value.Value.LocalizedText = (OpcUa_LocalizedText*)OpcUa_Alloc(sizeof(OpcUa_LocalizedText));
            OpcUa_LocalizedText_Initialize(value.Value.LocalizedText);
            OpcUa_LocalizedText_CopyTo(a_pRequest->InputArguments[1].Value.LocalizedText, value.Value.LocalizedText);
            UaServer_Events_SetEventField(a_pEvent, ConditionTypeField_Comment, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_DateTime;
            value.Value.DateTime = OpcUa_DateTime_UtcNow();
            UaServer_Events_SetEventField(a_pEvent, ConditionTypeField_Comment_SourceTimestamp, &value);
            OpcUa_Variant_Clear(&value);

            UaServer_Events_FireEvent(a_pEvent);

            /* get BaseNode of the SourceNode of the event and extract it's UserData */
            pSourceNode = ((OpcUa_Variant*)UaBase_Vector_Get(&a_pEvent->EventFields, BaseEventTypeField_SourceNode))->Value.NodeId;
            if (pSourceNode != OpcUa_Null)
            {
                OpcUa_BaseNode *pBaseNode;
                UaServer_GetNode(&g_pDemoProvider->AddressSpace, pSourceNode, &pBaseNode);
                if (pBaseNode != OpcUa_Null)
                {
                }
            }
        }
    }
    else
    {
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }

    return OpcUa_Good;
}

OpcUa_StatusCode UaProvider_Demo_CallConfirm(UaServer_Event *a_pEvent, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    if (a_pRequest->NoOfInputArguments == 2)
    {
        a_pResult->StatusCode = OpcUa_Good;

        a_pResult->NoOfInputArgumentResults = 2;
        a_pResult->InputArgumentResults = (OpcUa_StatusCode*)OpcUa_Alloc(a_pResult->NoOfInputArgumentResults * sizeof(OpcUa_StatusCode));
        OpcUa_MemSet(a_pResult->InputArgumentResults, 0, a_pResult->NoOfInputArgumentResults * sizeof(OpcUa_StatusCode));

        if (a_pRequest->InputArguments[0].Datatype != OpcUaType_ByteString
            || a_pRequest->InputArguments[0].ArrayType != OpcUa_VariantArrayType_Scalar)
        {
            a_pResult->InputArgumentResults[0] = OpcUa_BadTypeMismatch;
            a_pResult->StatusCode = OpcUa_BadTypeMismatch;
        }
        if (a_pRequest->InputArguments[1].Datatype != OpcUaType_LocalizedText
            || a_pRequest->InputArguments[1].ArrayType != OpcUa_VariantArrayType_Scalar)
        {
            a_pResult->InputArgumentResults[1] = OpcUa_BadTypeMismatch;
            a_pResult->StatusCode = OpcUa_BadTypeMismatch;
        }

        /* check EventId */
        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_ByteString *pEventId = UaServer_Events_GetEventId(a_pEvent);
            if (OpcUa_ByteString_Compare(pEventId, &a_pRequest->InputArguments[0].Value.ByteString) != 0)
            {
                a_pResult->StatusCode = OpcUa_BadEventIdUnknown;
            }
        }

        /* check ConfirmedState */
        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_Variant *pAckedState = (OpcUa_Variant*)UaBase_Vector_Get(&a_pEvent->EventFields, AcknowledgeableConditionTypeField_ConfirmedState_Id);
            a_pResult->StatusCode = OpcUa_BadConditionBranchAlreadyConfirmed;

            if (pAckedState != OpcUa_Null
                && pAckedState->Datatype == OpcUaType_Boolean
                && pAckedState->ArrayType == OpcUa_VariantArrayType_Scalar
                && pAckedState->Value.Boolean == OpcUa_False)
            {
                a_pResult->StatusCode = OpcUa_Good;
            }
        }

        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_Variant value;
            OpcUa_NodeId *pSourceNode;
            OpcUa_Variant_Initialize(&value);

            value.Datatype = OpcUaType_LocalizedText;
            value.Value.LocalizedText = (OpcUa_LocalizedText*)OpcUa_Alloc(sizeof(OpcUa_LocalizedText));
            OpcUa_LocalizedText_Initialize(value.Value.LocalizedText);
            OpcUa_String_StrnCat(&value.Value.LocalizedText->Text, OpcUa_String_FromCString("Confirmed"), OPCUA_STRING_LENDONTCARE);
            UaServer_Events_SetEventField(a_pEvent, AcknowledgeableConditionTypeField_ConfirmedState, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_Boolean;
            value.Value.Boolean = OpcUa_True;
            UaServer_Events_SetEventField(a_pEvent, AcknowledgeableConditionTypeField_ConfirmedState_Id, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_DateTime;
            value.Value.DateTime = OpcUa_DateTime_UtcNow();
            UaServer_Events_SetEventField(a_pEvent, AcknowledgeableConditionTypeField_ConfirmedState_TransitionTime, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_LocalizedText;
            value.Value.LocalizedText = (OpcUa_LocalizedText*)OpcUa_Alloc(sizeof(OpcUa_LocalizedText));
            OpcUa_LocalizedText_Initialize(value.Value.LocalizedText);
            OpcUa_LocalizedText_CopyTo(a_pRequest->InputArguments[1].Value.LocalizedText, value.Value.LocalizedText);
            UaServer_Events_SetEventField(a_pEvent, ConditionTypeField_Comment, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_DateTime;
            value.Value.DateTime = OpcUa_DateTime_UtcNow();
            UaServer_Events_SetEventField(a_pEvent, ConditionTypeField_Comment_SourceTimestamp, &value);
            OpcUa_Variant_Clear(&value);

            UaServer_Events_FireEvent(a_pEvent);

            /* get BaseNode of the SourceNode of the event and extract it's UserData */
            pSourceNode = ((OpcUa_Variant*)UaBase_Vector_Get(&a_pEvent->EventFields, BaseEventTypeField_SourceNode))->Value.NodeId;
            if (pSourceNode != OpcUa_Null)
            {
                OpcUa_BaseNode *pBaseNode;
                UaServer_GetNode(&g_pDemoProvider->AddressSpace, pSourceNode, &pBaseNode);
                if (pBaseNode != OpcUa_Null)
                {
                }
            }
        }
    }
    else
    {
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }

    return OpcUa_Good;
}

OpcUa_StatusCode UaProvider_Demo_CallAddComment(UaServer_Event *a_pEvent, OpcUa_CallMethodRequest* a_pRequest, OpcUa_CallMethodResult* a_pResult)
{
    if (a_pRequest->NoOfInputArguments == 2)
    {
        a_pResult->StatusCode = OpcUa_Good;

        a_pResult->NoOfInputArgumentResults = 2;
        a_pResult->InputArgumentResults = (OpcUa_StatusCode*)OpcUa_Alloc(a_pResult->NoOfInputArgumentResults * sizeof(OpcUa_StatusCode));
        OpcUa_MemSet(a_pResult->InputArgumentResults, 0, a_pResult->NoOfInputArgumentResults * sizeof(OpcUa_StatusCode));

        if (a_pRequest->InputArguments[0].Datatype != OpcUaType_ByteString
            || a_pRequest->InputArguments[0].ArrayType != OpcUa_VariantArrayType_Scalar)
        {
            a_pResult->InputArgumentResults[0] = OpcUa_BadTypeMismatch;
            a_pResult->StatusCode = OpcUa_BadTypeMismatch;
        }
        if (a_pRequest->InputArguments[1].Datatype != OpcUaType_LocalizedText
            || a_pRequest->InputArguments[1].ArrayType != OpcUa_VariantArrayType_Scalar)
        {
            a_pResult->InputArgumentResults[1] = OpcUa_BadTypeMismatch;
            a_pResult->StatusCode = OpcUa_BadTypeMismatch;
        }

        /* check EventId */
        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_ByteString *pEventId = UaServer_Events_GetEventId(a_pEvent);
            if (OpcUa_ByteString_Compare(pEventId, &a_pRequest->InputArguments[0].Value.ByteString) != 0)
            {
                a_pResult->StatusCode = OpcUa_BadEventIdUnknown;
            }
        }

        if (OpcUa_IsGood(a_pResult->StatusCode))
        {
            OpcUa_Variant value;
            OpcUa_NodeId *pSourceNode;
            OpcUa_Variant_Initialize(&value);

            value.Datatype = OpcUaType_LocalizedText;
            value.Value.LocalizedText = (OpcUa_LocalizedText*)OpcUa_Alloc(sizeof(OpcUa_LocalizedText));
            OpcUa_LocalizedText_Initialize(value.Value.LocalizedText);
            OpcUa_LocalizedText_CopyTo(a_pRequest->InputArguments[1].Value.LocalizedText, value.Value.LocalizedText);
            UaServer_Events_SetEventField(a_pEvent, ConditionTypeField_Comment, &value);
            OpcUa_Variant_Clear(&value);

            value.Datatype = OpcUaType_DateTime;
            value.Value.DateTime = OpcUa_DateTime_UtcNow();
            UaServer_Events_SetEventField(a_pEvent, ConditionTypeField_Comment_SourceTimestamp, &value);
            OpcUa_Variant_Clear(&value);

            UaServer_Events_FireEvent(a_pEvent);

            /* get BaseNode of the SourceNode of the event and extract it's UserData */
            pSourceNode = ((OpcUa_Variant*)UaBase_Vector_Get(&a_pEvent->EventFields, BaseEventTypeField_SourceNode))->Value.NodeId;
            if (pSourceNode != OpcUa_Null)
            {
                OpcUa_BaseNode *pBaseNode;
                UaServer_GetNode(&g_pDemoProvider->AddressSpace, pSourceNode, &pBaseNode);
                if (pBaseNode != OpcUa_Null)
                {
                }
            }
        }
    }
    else
    {
        a_pResult->StatusCode = OpcUa_BadArgumentsMissing;
    }

    return OpcUa_Good;
}
#endif

IFMETHODIMP(UaProvider_Demo_CallAsync)(UaServer_ProviderCallContext* a_pCallContext)
{
    OpcUa_CallRequest       *pRequest;
    OpcUa_CallResponse      *pResponse;
    OpcUa_Int32              i;
    OpcUa_NodeId            *pMethodId          = OpcUa_Null;
    OpcUa_BaseNode          *pMethodNode        = OpcUa_Null;
    OpcUa_BaseNode          *pObjectNode        = OpcUa_Null;

    OpcUa_ReturnErrorIfArgumentNull(a_pCallContext);

    pRequest  = a_pCallContext->pRequest;
    pResponse = a_pCallContext->pResponse;

    /* we will send exactly one callback */
    UaBase_Atomic_Increment(&a_pCallContext->nOutstandingCbs);

    for (i = 0; i < pRequest->NoOfMethodsToCall; i++)
    {
        if (pRequest->MethodsToCall[i].MethodId.NamespaceIndex == g_UaProviderDemo_uNamespaceIndex1)
        {
            pMethodId = &(pRequest->MethodsToCall[i].MethodId);
            pMethodNode = UaServer_GetNodeById(&pRequest->MethodsToCall[i].MethodId);
            if (pMethodNode == 0)
            {
                pResponse->Results[i].StatusCode = OpcUa_BadNodeIdUnknown;
                continue;
            }

            pObjectNode = UaServer_GetNodeById(&pRequest->MethodsToCall[i].ObjectId);
            if (pObjectNode == 0)
            {
                pResponse->Results[i].StatusCode = OpcUa_BadNodeIdUnknown;
                continue;
            }

#if UASERVER_SUPPORT_AUTHORIZATION
            /* check if current user is allowed to read */
            if (!UaServer_UserMgt_IsExecutable(OpcUa_BaseNode_GetINode(pMethodNode), a_pCallContext->pSession->UserIdentityData) ||
                !UaServer_UserMgt_IsExecutable(OpcUa_BaseNode_GetINode(pObjectNode), a_pCallContext->pSession->UserIdentityData))
            {
                pResponse->Results[i].StatusCode = OpcUa_BadUserAccessDenied;
                continue;
            }
#endif

            if (pMethodId->IdentifierType == OpcUa_IdentifierType_Numeric)
            {
                switch (pMethodId->Identifier.Numeric)
                {
                case Demo_BoilerType_FillId:
                    UaProvider_Demo_BoilerType_CallFill(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                    break;
                case Demo_BoilerType_HeatId:
                    UaProvider_Demo_BoilerType_CallHeat(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                    break;
                case Demo_Objects_Demo_CTT_References_Has3ForwardReferences2_Method1:
                    UaProvider_Demo_Has3ForwardReferences2_CallMethod1(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                    break;
                case Demo_Objects_Demo_CTT_References_Has3ForwardReferences2_Method2:
                    UaProvider_Demo_Has3ForwardReferences2_CallMethod2(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                    break;
                case Demo_Objects_Demo_CTT_References_Has3ForwardReferences2_Method3:
                    UaProvider_Demo_Has3ForwardReferences2_CallMethod3(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                    break;
                case Demo_Objects_Demo_CTT_References_Has3ForwardReferences5_ReferencedNode3:
                    UaProvider_Demo_Has3ForwardReferences5_CallReferencedNode3(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                    break;
                default:
                    break;
                }
            }
            else if (pMethodId->IdentifierType == OpcUa_IdentifierType_String)
            {
                if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_BoilerDemo_Boiler1_Fill) == 0)
                {
                    UaProvider_Demo_BoilerType_CallFill(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_BoilerDemo_Boiler1_Heat) == 0)
                {
                    UaProvider_Demo_BoilerType_CallHeat(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_CTT_NodeClasses_Method) == 0)
                {
                    UaProvider_Demo_NodeClasses_CallMethod(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_DynamicNodes_CreateDynamicNode) == 0)
                {
                    UaProvider_Demo_DynamicNodes_CallCreateDynamicNode(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_DynamicNodes_DeleteDynamicNode) == 0)
                {
                    UaProvider_Demo_DynamicNodes_CallDeleteDynamicNode(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_History_StartLogging) == 0)
                {
                    UaProvider_Demo_History_CallStartLogging(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_History_StopLogging) == 0)
                {
                    UaProvider_Demo_History_CallStopLogging(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_Method_Multiply) == 0)
                {
                    UaProvider_Demo_Method_CallMultiply(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_Method_VectorAdd) == 0)
                {
                    UaProvider_Demo_Method_CallVectorAdd(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_SetSimulationSpeed) == 0)
                {
                    UaProvider_Demo_Demo_CallSetSimulationSpeed(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_StartSimulation) == 0)
                {
                    UaProvider_Demo_Demo_CallStartSimulation(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                else if(OpcUa_StrCmpA(OpcUa_String_GetRawString(&pMethodId->Identifier.String), Demo_Objects_Demo_StopSimulation) == 0)
                {
                    UaProvider_Demo_Demo_CallStopSimulation(a_pCallContext, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
            }
        }


#if UASERVER_SUPPORT_EVENTS
        else if (pRequest->MethodsToCall[i].ObjectId.NamespaceIndex == g_UaProviderDemo_uNamespaceIndex1
                 && pRequest->MethodsToCall[i].MethodId.NamespaceIndex == 0
                 && pRequest->MethodsToCall[i].MethodId.IdentifierType == OpcUa_IdentifierType_Numeric)
        {
            switch (pRequest->MethodsToCall[i].MethodId.Identifier.Numeric)
            {
            case OpcUaId_AcknowledgeableConditionType_Acknowledge:
            {
                UaServer_Event *pEvent = UaServer_Events_GetConditionByNodeId(g_UaProviderDemo_uNamespaceIndex1,
                                         &pRequest->MethodsToCall[i].ObjectId);
                if (pEvent != OpcUa_Null)
                {
                    UaProvider_Demo_CallAcknowledge(pEvent, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                break;
            }
            case OpcUaId_AcknowledgeableConditionType_Confirm:
            {
                UaServer_Event *pEvent = UaServer_Events_GetConditionByNodeId(g_UaProviderDemo_uNamespaceIndex1,
                                         &pRequest->MethodsToCall[i].ObjectId);
                if (pEvent != OpcUa_Null)
                {
                    UaProvider_Demo_CallConfirm(pEvent, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                break;
            }
            case OpcUaId_ConditionType_AddComment:
            {
                UaServer_Event *pEvent = UaServer_Events_GetConditionByNodeId(g_UaProviderDemo_uNamespaceIndex1,
                                         &pRequest->MethodsToCall[i].ObjectId);
                if (pEvent != OpcUa_Null)
                {
                    UaProvider_Demo_CallAddComment(pEvent, &pRequest->MethodsToCall[i], &pResponse->Results[i]);
                }
                break;
            }
            default:
                break;
            }
        }
#endif
    }
    /* send callback */
    UaServer_CallComplete(a_pCallContext);

    return OpcUa_Good;
}

OPCUA_END_EXTERN_C