#include "uaprovider_demo_types_1.h"
#include <opcua_platformdefs.h>
#include <opcua_statuscodes.h>
#include <opcua_errorhandling.h>
#include <opcua_memory.h>
#include <opcua_string.h>
#include <opcua_guid.h>
#include <opcua_encoder.h>
#include <opcua_decoder.h>
#include <opcua_identifiers.h>
#include "uaprovider_demo_identifiers_1.h"
#if (UASDK_MAJOR_VERSION == 1 && UASDK_MINOR_VERSION == 5 && UASDK_PATCH_VERSION == 1)
#ifndef _OPCUA_UNIONFIELD_HELPERS
#define _OPCUA_UNIONFIELD_HELPERS
#define OpcUa_UnionField_Initialize(xType, xName) OpcUa_##xType##_Initialize(&a_pValue->Value.xName);
#define OpcUa_UnionField_InitializeEncodeable(xType, xName) xType##_Initialize(&a_pValue->Value.xName);
#define OpcUa_UnionField_InitializeEnumerated(xType, xName) xType##_Initialize(&a_pValue->Value.xName);
#define OpcUa_UnionField_InitializeArray(xType, xName) \
{ \
a_pValue->Value.xName.Data = OpcUa_Null; \
a_pValue->Value.xName.Count = 0; \
}
#define OpcUa_UnionField_InitializeEncodeableArray(xType, xName) OpcUa_UnionField_InitializeArray(xType, xName)
#define OpcUa_UnionField_InitializeEnumeratedArray(xType, xName) OpcUa_UnionField_InitializeArray(xType, xName)
#define OpcUa_UnionField_Clear(xType, xName) OpcUa_##xType##_Clear(&a_pValue->Value.xName);
#define OpcUa_UnionField_ClearEncodeable(xType, xName) xType##_Clear(&a_pValue->Value.xName);
#define OpcUa_UnionField_ClearEnumerated(xType, xName) xType##_Clear(&a_pValue->Value.xName);
#define OpcUa_UnionField_ClearArray(xType, xName)\
{ \
int ii; \
\
for (ii = 0; ii < a_pValue->Value.xName.Count && a_pValue->Value.xName.Data != OpcUa_Null; ii++) \
{ \
OpcUa_##xType##_Clear(&(a_pValue->Value.xName.Data[ii])); \
} \
\
OpcUa_Free(a_pValue->Value.xName.Data); \
\
a_pValue->Value.xName.Data = OpcUa_Null; \
a_pValue->Value.xName.Count = 0; \
}
#define OpcUa_UnionField_ClearEncodeableArray(xType, xName) \
{ \
int ii; \
\
for (ii = 0; ii < a_pValue->Value.xName.Count && a_pValue->Value.xName.Data != OpcUa_Null; ii++) \
{ \
xType##_Clear(&(a_pValue->Value.xName.Data[ii])); \
} \
\
OpcUa_Free(a_pValue->Value.xName.Data); \
\
a_pValue->Value.xName.Data = OpcUa_Null; \
a_pValue->Value.xName.Count = 0; \
}
#define OpcUa_UnionField_ClearEnumeratedArray(xType, xName) \
{ \
OpcUa_Free(a_pValue->Value.xName.Data); \
a_pValue->Value.xName.Data = OpcUa_Null; \
a_pValue->Value.xName.Count = 0; \
}
#define OpcUa_UnionField_Compare(xType, xName) {OpcUa_Int i = OpcUa_##xType##_Compare(&a_pValue1->Value.xName, &a_pValue2->Value.xName); if (i) return i;}
#define OpcUa_UnionField_CompareEncodeable(xType, xName) {OpcUa_Int i = xType##_Compare(&a_pValue1->Value.xName, &a_pValue2->Value.xName); if (i) return i;}
#define OpcUa_UnionField_CompareEnumerated(xType, xName) {OpcUa_Int i = OpcUa_Int32_Compare(&a_pValue1->Value.xName, &a_pValue2->Value.xName); if (i) return i;}
#define OpcUa_UnionField_CompareArrayStart(xType, xName) \
if (a_pValue1->Value.xName.Count != a_pValue2->Value.xName.Count) \
{ \
return 1; \
} \
if (a_pValue1->Value.xName.Data == a_pValue2->Value.xName.Data) \
{ \
return 0; \
} \
if (a_pValue1->Value.xName.Data == OpcUa_Null || a_pValue2->Value.xName.Data == OpcUa_Null) \
{ \
return 1; \
}
#define OpcUa_UnionField_CompareArray(xType, xName)\
{ \
int ii; \
\
OpcUa_UnionField_CompareArrayStart(xType, xName) \
\
for (ii = 0; ii < a_pValue1->Value.xName.Count; ii++) \
{ \
if (OpcUa_##xType##_Compare(&(a_pValue1->Value.xName.Data[ii]), &(a_pValue2->Value.xName.Data[ii]))){return 1;}; \
} \
}
#define OpcUa_UnionField_CompareEncodeableArray(xType, xName) \
{ \
int ii; \
\
OpcUa_UnionField_CompareArrayStart(xType, xName) \
\
for (ii = 0; ii < a_pValue1->Value.xName.Count; ii++) \
{ \
if (xType##_Compare(&(a_pValue1->Value.xName.Data[ii]), &(a_pValue2->Value.xName.Data[ii]))){return 1;}; \
} \
}
#define OpcUa_UnionField_CompareEnumeratedArray(xType, xName) \
{ \
int ii; \
\
OpcUa_UnionField_CompareArrayStart(xType, xName) \
\
for (ii = 0; ii < a_pValue1->Value.xName.Count; ii++) \
{ \
if (a_pValue1->Value.xName.Data[ii] != a_pValue2->Value.xName.Data[ii]){return 1;}; \
} \
}
#define OpcUa_UnionField_Copy(xType, xName) \
{ \
a_pDestination->xName = (OpcUa_##xType*)OpcUa_Alloc(sizeof(OpcUa_##xType)); \
OpcUa_GotoErrorIfAllocFailed(a_pDestination->xName); \
OpcUa_##xType##_Initialize(a_pDestination->xName); \
uStatus = OpcUa_##xType##_CopyTo(a_pSource->xName, a_pDestination->xName); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_CopyTo(xType, xName) uStatus = OpcUa_##xType##_CopyTo(&(a_pSource->Value.xName), &(a_pDestination->Value.xName)); OpcUa_GotoErrorIfBad(uStatus);
#define OpcUa_UnionField_CopyToScalar(xType, xName) (a_pDestination->Value.xName = a_pSource->Value.xName)
#define OpcUa_UnionField_CopyToEncodeable(xType, xName) xType##_CopyTo(&a_pSource->Value.xName, &a_pDestination->Value.xName)
#define OpcUa_UnionField_CopyToEnumerated(xType, xName) a_pDestination->Value.xName = a_pSource->Value.xName
#define OpcUa_UnionField_CopyToArray(xType, xName)\
{ \
int ii; \
\
for (ii = 0; ii < a_pSource->NoOf##xName && a_pSource->xName != OpcUa_Null; ii++) \
{ \
uStatus = OpcUa_##xType##_CopyTo(&(a_pSource->xName[ii]), &(a_pDestination->xName[ii])); \
OpcUa_GotoErrorIfBad(uStatus); \
} \
}
#define OpcUa_UnionField_CopyArray(xType, xName)\
if (a_pSource->Value.xName.Count > 0 && a_pSource->Value.xName.Data != OpcUa_Null) \
{ \
int ii; \
\
a_pDestination->Value.xName.Data = (OpcUa_##xType*)OpcUa_Alloc(sizeof(OpcUa_##xType) * a_pSource->Value.xName.Count); \
OpcUa_GotoErrorIfAllocFailed(a_pDestination->Value.xName.Data); \
OpcUa_MemSet(a_pDestination->Value.xName.Data, 0, sizeof(OpcUa_##xType) * a_pSource->Value.xName.Count); \
\
for (ii = 0; ii < a_pSource->Value.xName.Count && a_pSource->Value.xName.Data != OpcUa_Null; ii++) \
{ \
uStatus = OpcUa_##xType##_CopyTo(&(a_pSource->Value.xName.Data[ii]), &(a_pDestination->Value.xName.Data[ii])); \
OpcUa_GotoErrorIfBad(uStatus); \
} \
a_pDestination->Value.xName.Count = a_pSource->Value.xName.Count; \
} \
else \
{ \
a_pDestination->Value.xName.Count = 0; \
a_pDestination->Value.xName.Data = OpcUa_Null; \
}
#define OpcUa_UnionField_CopyToEncodeableArray(xType, xName) \
{ \
int ii; \
\
for (ii = 0; ii < a_pSource->NoOf##xName && a_pSource->xName != OpcUa_Null; ii++) \
{ \
xType##_CopyTo(&(a_pSource->xName[ii]), &(a_pDestination->xName[ii])); \
} \
}
#define OpcUa_UnionField_CopyEncodeableArray(xType, xName) \
if (a_pSource->Value.xName.Count > 0 && a_pSource->Value.xName.Data != OpcUa_Null) \
{ \
int ii; \
\
a_pDestination->Value.xName.Data = (xType*)OpcUa_Alloc(sizeof(xType) * a_pSource->Value.xName.Count); \
OpcUa_GotoErrorIfAllocFailed(a_pDestination->Value.xName.Data); \
OpcUa_MemSet(a_pDestination->Value.xName.Data, 0, sizeof(xType) * a_pSource->Value.xName.Count); \
\
for (ii = 0; ii < a_pSource->Value.xName.Count && a_pSource->Value.xName.Data != OpcUa_Null; ii++) \
{ \
uStatus = xType##_CopyTo(&(a_pSource->Value.xName.Data[ii]), &(a_pDestination->Value.xName.Data[ii])); \
OpcUa_GotoErrorIfBad(uStatus); \
} \
a_pDestination->Value.xName.Count = a_pSource->Value.xName.Count; \
} \
else \
{ \
a_pDestination->Value.xName.Count = 0; \
a_pDestination->Value.xName.Data = OpcUa_Null; \
}
#define OpcUa_UnionField_CopyEnumeratedArray(xType, xName) \
if (a_pSource->Value.xName.Count > 0 && a_pSource->Value.xName.Data != OpcUa_Null) \
{ \
a_pDestination->Value.xName.Data = (xType*)OpcUa_Alloc(a_pSource->Value.xName.Count * sizeof(xType)); \
OpcUa_GotoErrorIfAllocFailed(a_pDestination->Value.xName.Data); \
OpcUa_MemCpy(a_pDestination->Value.xName.Data, a_pSource->Value.xName.Count * sizeof(xType), a_pSource->Value.xName.Data, a_pSource->Value.xName.Count * sizeof(xType)); \
a_pDestination->Value.xName.Count = a_pSource->Value.xName.Count; \
} \
else \
{ \
a_pDestination->Value.xName.Count = 0; \
a_pDestination->Value.xName.Data = OpcUa_Null; \
}
#define OpcUa_UnionField_CopyScalarArray(xType, xName) \
if (a_pSource->Value.xName.Count > 0 && a_pSource->Value.xName.Data != OpcUa_Null) \
{ \
a_pDestination->Value.xName.Data = (OpcUa_##xType*)OpcUa_Alloc(a_pSource->Value.xName.Count * sizeof(OpcUa_##xType)); \
OpcUa_GotoErrorIfAllocFailed(a_pDestination->Value.xName.Data); \
OpcUa_MemCpy(a_pDestination->Value.xName.Data, a_pSource->Value.xName.Count * sizeof(OpcUa_##xType), a_pSource->Value.xName.Data, a_pSource->Value.xName.Count * sizeof(OpcUa_##xType)); \
a_pDestination->Value.xName.Count = a_pSource->Value.xName.Count; \
} \
else \
{ \
a_pDestination->Value.xName.Count = 0; \
a_pDestination->Value.xName.Data = OpcUa_Null; \
}
#define OpcUa_UnionField_GetSize(xType, xName) \
{ \
OpcUa_Int32 uFieldSize; \
uStatus = a_pEncoder->Write##xType(a_pEncoder, #xName, &a_pValue->Value.xName, &uFieldSize); \
OpcUa_GotoErrorIfBad(uStatus); \
iSize += uFieldSize; \
}
#define OpcUa_UnionField_GetSizeEncodeable(xType, xName) \
{ \
OpcUa_Int32 uFieldSize; \
uStatus = a_pEncoder->WriteEncodeable(a_pEncoder, #xName, &a_pValue->Value.xName, &xType##_EncodeableType, &uFieldSize); \
OpcUa_GotoErrorIfBad(uStatus); \
iSize += uFieldSize; \
}
#define OpcUa_UnionField_GetSizeEnumerated(xType, xName) \
{ \
OpcUa_Int32 uFieldSize; \
uStatus = a_pEncoder->WriteEnumerated(a_pEncoder, #xName, (OpcUa_Int32*)&a_pValue->Value.xName, &xType##_EnumeratedType, &uFieldSize); \
OpcUa_GotoErrorIfBad(uStatus); \
iSize += uFieldSize; \
}
#define OpcUa_UnionField_GetSizeArray(xType, xName) \
{ \
OpcUa_Int32 uFieldSize; \
uStatus = a_pEncoder->Write##xType##Array(a_pEncoder, #xName, a_pValue->Value.xName.Data, a_pValue->Value.xName.Count, &uFieldSize); \
OpcUa_GotoErrorIfBad(uStatus); \
iSize += uFieldSize; \
}
#define OpcUa_UnionField_GetSizeEncodeableArray(xType, xName) \
{ \
OpcUa_Int32 uFieldSize; \
uStatus = a_pEncoder->WriteEncodeableArray(a_pEncoder, #xName, a_pValue->Value.xName.Data, a_pValue->Value.xName.Count, &xType##_EncodeableType, &uFieldSize); \
OpcUa_GotoErrorIfBad(uStatus); \
iSize += uFieldSize; \
}
#define OpcUa_UnionField_GetSizeEnumeratedArray(xType, xName) \
{ \
OpcUa_Int32 uFieldSize; \
uStatus = a_pEncoder->WriteEnumeratedArray(a_pEncoder, #xName, (OpcUa_Int32*)a_pValue->Value.xName.Data, a_pValue->Value.xName.Count, &xType##_EnumeratedType, &uFieldSize); \
OpcUa_GotoErrorIfBad(uStatus); \
iSize += uFieldSize; \
}
#define OpcUa_UnionField_Write(xType, xName) \
{ \
uStatus = a_pEncoder->Write##xType(a_pEncoder, #xName, &a_pValue->Value.xName, OpcUa_Null); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_WriteEncodeable(xType, xName) \
{ \
uStatus = a_pEncoder->WriteEncodeable(a_pEncoder, #xName, &a_pValue->Value.xName, &xType##_EncodeableType, OpcUa_Null); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_WriteEnumerated(xType, xName) \
{ \
uStatus = a_pEncoder->WriteEnumerated(a_pEncoder, #xName, (OpcUa_Int32*)&a_pValue->Value.xName, &xType##_EnumeratedType, OpcUa_Null); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_WriteArray(xType, xName) \
{ \
uStatus = a_pEncoder->Write##xType##Array(a_pEncoder, #xName, a_pValue->Value.xName.Data, a_pValue->Value.xName.Count, OpcUa_Null); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_WriteEncodeableArray(xType, xName) \
{ \
uStatus = a_pEncoder->WriteEncodeableArray(a_pEncoder, #xName, a_pValue->Value.xName.Data, a_pValue->Value.xName.Count, &xType##_EncodeableType, OpcUa_Null); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_WriteEnumeratedArray(xType, xName) \
{ \
uStatus = a_pEncoder->WriteEnumeratedArray(a_pEncoder, #xName, (OpcUa_Int32*)a_pValue->Value.xName.Data, a_pValue->Value.xName.Count, &xType##_EnumeratedType, OpcUa_Null); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_Read(xType, xName) \
{ \
uStatus = a_pDecoder->Read##xType(a_pDecoder, #xName, &a_pValue->Value.xName); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadEncodeable(xType, xName) \
{ \
uStatus = a_pDecoder->ReadEncodeable(a_pDecoder, #xName, &xType##_EncodeableType, &a_pValue->Value.xName); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadEnumerated(xType, xName) \
{ \
uStatus = a_pDecoder->ReadEnumerated(a_pDecoder, #xName, &xType##_EnumeratedType, (OpcUa_Int32*)&a_pValue->Value.xName); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadArray(xType, xName) \
{ \
uStatus = a_pDecoder->Read##xType##Array(a_pDecoder, #xName, &(a_pValue->Value.xName.Data), &(a_pValue->Value.xName.Count)); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadEncodeableArray(xType, xName) \
{ \
uStatus = a_pDecoder->ReadEncodeableArray(a_pDecoder, #xName, &xType##_EncodeableType, (OpcUa_Void**)(&(a_pValue->Value.xName.Data)), &(a_pValue->Value.xName.Count)); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadEnumeratedArray(xType, xName) \
{ \
uStatus = a_pDecoder->ReadEnumeratedArray(a_pDecoder, #xName, &xType##_EnumeratedType, (OpcUa_Int32**)&(a_pValue->Value.xName.Data), &(a_pValue->Value.xName.Count)); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadEncodeableArray(xType, xName) \
{ \
uStatus = a_pDecoder->ReadEncodeableArray(a_pDecoder, #xName, &xType##_EncodeableType, (OpcUa_Void**)(&(a_pValue->Value.xName.Data)), &(a_pValue->Value.xName.Count)); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#define OpcUa_UnionField_ReadEnumeratedArray(xType, xName) \
{ \
uStatus = a_pDecoder->ReadEnumeratedArray(a_pDecoder, #xName, &xType##_EnumeratedType, (OpcUa_Int32**)&(a_pValue->Value.xName.Data), &(a_pValue->Value.xName.Count)); \
OpcUa_GotoErrorIfBad(uStatus); \
}
#endif
#endif
#ifndef OPCUA_EXCLUDE_Demo_HeaterStatus
static struct _OpcUa_EnumeratedValue g_Demo_HeaterStatus_EnumeratedValues[] =
{
{"Off", 0},
{"Heating", 1},
{"Cooling", 2},
{ OpcUa_Null, 0 }
};
struct _OpcUa_EnumeratedType Demo_HeaterStatus_EnumeratedType =
{
"HeaterStatus",
g_Demo_HeaterStatus_EnumeratedValues
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_Priority
static struct _OpcUa_EnumeratedValue g_Demo_Priority_EnumeratedValues[] =
{
{"Low", 10},
{"Normal", 40},
{"High", 70},
{"Urgent", 90},
{"Immediate", 100},
{ OpcUa_Null, 0 }
};
struct _OpcUa_EnumeratedType Demo_Priority_EnumeratedType =
{
"Priority",
g_Demo_Priority_EnumeratedValues
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_StructureWithOptionalFields
OpcUa_Void Demo_StructureWithOptionalFields_Initialize(Demo_StructureWithOptionalFields* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
a_pValue->EncodingMask = 0;
OpcUa_Field_Initialize(Int32, MandatoryInt32);
OpcUa_Field_Initialize(Int32, OptionalInt32);
OpcUa_Field_InitializeArray(
String, MandatoryStringArray);
OpcUa_Field_InitializeArray(
String, OptionalStringArray);
}
}
OpcUa_Void Demo_StructureWithOptionalFields_Clear(Demo_StructureWithOptionalFields* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Clear(Int32, MandatoryInt32);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Field_Clear(Int32, OptionalInt32);
}
OpcUa_Field_ClearArray(
String, MandatoryStringArray);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
OpcUa_Field_ClearArray(
String, OptionalStringArray);
}
a_pValue->EncodingMask = 0;
}
}
OpcUa_StatusCode Demo_StructureWithOptionalFields_GetSize(Demo_StructureWithOptionalFields* a_pValue, OpcUa_Encoder* a_pEncoder, OpcUa_Int32* a_pSize)
{
OpcUa_Int32 iSize = 0;
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_StructureWithOptionalFields_GetSize");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_ReturnErrorIfArgumentNull(a_pSize);
*a_pSize = -1;
OpcUa_Field_GetSize(UInt32, EncodingMask);
OpcUa_Field_GetSize(Int32, MandatoryInt32);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Field_GetSize(Int32, OptionalInt32);
}
OpcUa_Field_GetSizeArray(
String, MandatoryStringArray);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
OpcUa_Field_GetSizeArray(
String, OptionalStringArray);
}
*a_pSize = iSize;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
*a_pSize = -1;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_StructureWithOptionalFields_Encode(Demo_StructureWithOptionalFields* a_pValue, OpcUa_Encoder* a_pEncoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_StructureWithOptionalFields_Encode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_Field_Write(UInt32, EncodingMask);
OpcUa_Field_Write(Int32, MandatoryInt32);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Field_Write(Int32, OptionalInt32);
}
OpcUa_Field_WriteArray(
String, MandatoryStringArray);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
OpcUa_Field_WriteArray(
String, OptionalStringArray);
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_StructureWithOptionalFields_Decode(Demo_StructureWithOptionalFields* a_pValue, OpcUa_Decoder* a_pDecoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_StructureWithOptionalFields_Decode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pDecoder);
Demo_StructureWithOptionalFields_Initialize(a_pValue);
OpcUa_Field_Read(UInt32, EncodingMask);
OpcUa_Field_Read(Int32, MandatoryInt32);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Field_Read(Int32, OptionalInt32);
}
OpcUa_Field_ReadArray(
String, MandatoryStringArray);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
OpcUa_Field_ReadArray(
String, OptionalStringArray);
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_StructureWithOptionalFields_Clear(a_pValue);
OpcUa_FinishErrorHandling;
}
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
OPCUA_EXPORT OpcUa_Int Demo_StructureWithOptionalFields_Compare(const Demo_StructureWithOptionalFields* a_pValue1, const Demo_StructureWithOptionalFields* a_pValue2)
{
if (a_pValue1 == a_pValue2)
{
return 0;
}
OpcUa_Field_Compare(UInt32, EncodingMask);
OpcUa_Field_Compare(Int32, MandatoryInt32);
if ((a_pValue1->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Field_Compare(Int32, OptionalInt32);
}
OpcUa_Field_CompareArray(
String, MandatoryStringArray);
if ((a_pValue1->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
OpcUa_Field_CompareArray(
String, OptionalStringArray);
}
return 0;
}
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Copy(
const Demo_StructureWithOptionalFields* a_pSource, Demo_StructureWithOptionalFields** a_ppCopy)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Copy");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_ppCopy);
*a_ppCopy = OpcUa_Alloc(sizeof( Demo_StructureWithOptionalFields ));
OpcUa_GotoErrorIfAllocFailed(*a_ppCopy);
uStatus = Demo_StructureWithOptionalFields_CopyTo(a_pSource, *a_ppCopy);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppCopy != OpcUa_Null)
{
OpcUa_Free(*a_ppCopy);
*a_ppCopy = OpcUa_Null;
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_CopyTo(
const Demo_StructureWithOptionalFields* a_pSource, Demo_StructureWithOptionalFields* a_pDestination)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_CopyTo");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_pDestination);
Demo_StructureWithOptionalFields_Initialize(a_pDestination);
a_pDestination->EncodingMask = a_pSource->EncodingMask;
OpcUa_Field_CopyToScalar(Int32, MandatoryInt32);
if ((a_pSource->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Field_CopyToScalar(Int32, OptionalInt32);
}
OpcUa_Field_CopyArray(
String, MandatoryStringArray);
if ((a_pSource->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
OpcUa_Field_CopyArray(
String, OptionalStringArray);
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_StructureWithOptionalFields_Clear(a_pDestination);
OpcUa_FinishErrorHandling;
}
#endif
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_ArrayFromVariant(
OpcUa_Variant* a_pVariant, OpcUa_Int32 *a_pNoOfValues, Demo_StructureWithOptionalFields **a_ppValues, OpcUa_Boolean a_bDetach)
{
OpcUa_Int32 i;
Demo_StructureWithOptionalFields *pValue;
Demo_StructureWithOptionalFields *pValues = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_ArrayFromVariant");
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++)
{
|| !a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type
|| a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type->TypeId != Demo_StructureWithOptionalFieldsId)
{
return OpcUa_BadInvalidArgument;
}
}
*a_pNoOfValues = 0;
if (a_pVariant->
Value.Array.Length > 0)
{
pValues = (Demo_StructureWithOptionalFields*) OpcUa_Alloc(a_pVariant->
Value.Array.Length *
sizeof(Demo_StructureWithOptionalFields));
OpcUa_GotoErrorIfAllocFailed(pValues);
OpcUa_MemSet(pValues, 0, a_pVariant->
Value.Array.Length *
sizeof(Demo_StructureWithOptionalFields));
for (i=0; i<a_pVariant->
Value.Array.Length; i++)
{
pValue = (Demo_StructureWithOptionalFields*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object;
if (a_bDetach)
{
pValues[i] = *pValue;
Demo_StructureWithOptionalFields_Initialize((Demo_StructureWithOptionalFields*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object);
OpcUa_ExtensionObject_Clear(&a_pVariant->
Value.Array.Value.ExtensionObjectArray[i]);
}
else
{
uStatus = Demo_StructureWithOptionalFields_CopyTo(pValue, &pValues[i]);
OpcUa_GotoErrorIfBad(uStatus);
}
}
*a_ppValues = pValues;
*a_pNoOfValues = a_pVariant->
Value.Array.Length;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (pValues)
{
for (i = 0; i < a_pVariant->
Value.Array.Length; i++)
{
Demo_StructureWithOptionalFields_Clear(&pValues[i]);
}
OpcUa_Free(pValues);
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_ArrayToVariant(OpcUa_Int32 *a_pNoOfValues, Demo_StructureWithOptionalFields **a_ppValues,
OpcUa_Variant* a_pVariant, OpcUa_Boolean a_bAttach)
{
OpcUa_Int32 i;
Demo_StructureWithOptionalFields *pValue;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_ArrayToVariant");
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;
if (*a_pNoOfValues > 0)
{
OpcUa_ReturnErrorIfAllocFailed(a_pVariant->
Value.Array.Value.ExtensionObjectArray);
a_pVariant->
Value.Array.Length = *a_pNoOfValues;
for (i=0; i<*a_pNoOfValues; i++)
{
uStatus = OpcUa_EncodeableObject_CreateExtension(&Demo_StructureWithOptionalFields_EncodeableType, &a_pVariant->
Value.Array.Value.ExtensionObjectArray[i], (OpcUa_Void**)&pValue);
OpcUa_GotoErrorIfBad(uStatus);
if (a_bAttach)
{
OpcUa_MemCpy(pValue, sizeof (Demo_StructureWithOptionalFields), (*a_ppValues)+i, sizeof(Demo_StructureWithOptionalFields));
}
else
{
uStatus = Demo_StructureWithOptionalFields_CopyTo(&(*a_ppValues)[i], pValue);
OpcUa_GotoErrorIfBad(uStatus);
}
}
if (a_bAttach)
{
OpcUa_Free(*a_ppValues);
*a_pNoOfValues = 0;
*a_ppValues = OpcUa_Null;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_Variant_Clear(a_pVariant);
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT OpcUa_Boolean Demo_StructureWithOptionalFields_Is_OptionalInt32_Set(const Demo_StructureWithOptionalFields *a_pValue)
{
return (a_pValue && (a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0) ? OpcUa_True : OpcUa_False;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Unset_OptionalInt32(Demo_StructureWithOptionalFields *a_pValue)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Unset_OptionalInt32");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_GotoErrorIfTrue((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) == 0, OpcUa_BadInvalidState);
OpcUa_Int32_Clear(&a_pValue->OptionalInt32);
a_pValue->EncodingMask &= ~Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Get_OptionalInt32(
const Demo_StructureWithOptionalFields *a_pValue, OpcUa_Int32 *a_pOptionalInt32)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Get_OptionalInt32");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pOptionalInt32);
OpcUa_GotoErrorIfTrue((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) == 0, OpcUa_BadNotFound);
*a_pOptionalInt32 = a_pValue->OptionalInt32;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Set_OptionalInt32(Demo_StructureWithOptionalFields *a_pValue, OpcUa_Int32 *a_pOptionalInt32)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Set_OptionalInt32");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pOptionalInt32);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32) != 0)
{
OpcUa_Int32_Clear(&a_pValue->OptionalInt32);
}
a_pValue->EncodingMask |= Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32;
a_pValue->OptionalInt32 = *a_pOptionalInt32;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
a_pValue->EncodingMask &= ~Demo_StructureWithOptionalFields_OptionalFields_OptionalInt32;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT OpcUa_Boolean Demo_StructureWithOptionalFields_Is_OptionalStringArray_Set(const Demo_StructureWithOptionalFields *a_pValue)
{
return (a_pValue && (a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0) ? OpcUa_True : OpcUa_False;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Unset_OptionalStringArray(Demo_StructureWithOptionalFields *a_pValue)
{
OpcUa_Int32 i;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Unset_OptionalStringArray");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_GotoErrorIfTrue((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) == 0, OpcUa_BadInvalidState);
for (i = 0; i < a_pValue->NoOfOptionalStringArray; i++)
{
OpcUa_String_Clear(&a_pValue->OptionalStringArray[i]);
}
OpcUa_Free(a_pValue->OptionalStringArray);
a_pValue->NoOfOptionalStringArray = 0;
a_pValue->OptionalStringArray = OpcUa_Null;
a_pValue->EncodingMask &= ~Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Get_OptionalStringArray(
const Demo_StructureWithOptionalFields *a_pValue, OpcUa_Int32 *a_pNoOfOptionalStringArray,
OpcUa_String **a_ppOptionalStringArray)
{
OpcUa_Int32 i;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Get_OptionalStringArray");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pNoOfOptionalStringArray);
OpcUa_ReturnErrorIfArgumentNull(a_ppOptionalStringArray);
*a_pNoOfOptionalStringArray = 0;
*a_ppOptionalStringArray = OpcUa_Null;
OpcUa_GotoErrorIfTrue((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) == 0, OpcUa_BadNotFound);
if (a_pValue->NoOfOptionalStringArray <= 0) {return OpcUa_Good;}
*a_ppOptionalStringArray = OpcUa_Alloc(a_pValue->NoOfOptionalStringArray *
sizeof(
OpcUa_String));
OpcUa_GotoErrorIfAllocFailed(*a_ppOptionalStringArray);
*a_pNoOfOptionalStringArray = a_pValue->NoOfOptionalStringArray;
for (i = 0; i < a_pValue->NoOfOptionalStringArray; i++)
{
OpcUa_String_Initialize(&(*a_ppOptionalStringArray)[i]);
if (OpcUa_IsNotGood(uStatus)) {continue;}
uStatus = OpcUa_String_CopyTo(&a_pValue->OptionalStringArray[i], &(*a_ppOptionalStringArray)[i]);
}
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppOptionalStringArray)
{
for (i = 0; i < a_pValue->NoOfOptionalStringArray; i++)
{
OpcUa_String_Clear(&(*a_ppOptionalStringArray)[i]);
}
OpcUa_Free(*a_ppOptionalStringArray);
}
*a_pNoOfOptionalStringArray = 0;
*a_ppOptionalStringArray = OpcUa_Null;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_StructureWithOptionalFields_Set_OptionalStringArray(Demo_StructureWithOptionalFields *a_pValue, OpcUa_Int32 a_NoOfOptionalStringArray,
OpcUa_String *a_pOptionalStringArray)
{
OpcUa_Int32 i;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_StructureWithOptionalFields_Set_OptionalStringArray");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pOptionalStringArray);
if ((a_pValue->EncodingMask & Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray) != 0)
{
for (i = 0; i < a_pValue->NoOfOptionalStringArray; i++)
{
OpcUa_String_Clear(&a_pValue->OptionalStringArray[i]);
}
OpcUa_Free(a_pValue->OptionalStringArray);
a_pValue->NoOfOptionalStringArray = 0;
a_pValue->OptionalStringArray = OpcUa_Null;
a_pValue->EncodingMask &= ~Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray;
}
a_pValue->EncodingMask |= Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray;
if (a_NoOfOptionalStringArray <= 0) {return OpcUa_Good;}
a_pValue->OptionalStringArray = OpcUa_Alloc(a_NoOfOptionalStringArray *
sizeof(
OpcUa_String));
OpcUa_GotoErrorIfAllocFailed(a_pValue->OptionalStringArray);
a_pValue->NoOfOptionalStringArray = a_NoOfOptionalStringArray;
for (i = 0; i < a_NoOfOptionalStringArray; i++)
{
OpcUa_String_Initialize(&a_pValue->OptionalStringArray[i]);
if (OpcUa_IsNotGood(uStatus)) {continue;}
uStatus = OpcUa_String_CopyTo(&a_pOptionalStringArray[i], &a_pValue->OptionalStringArray[i]);
}
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
a_pValue->EncodingMask &= ~Demo_StructureWithOptionalFields_OptionalFields_OptionalStringArray;
if (a_pValue->OptionalStringArray)
{
for (i = 0; i < a_NoOfOptionalStringArray; i++)
{
OpcUa_String_Clear(&a_pValue->OptionalStringArray[i]);
}
OpcUa_Free(a_pValue->OptionalStringArray);
a_pValue->NoOfOptionalStringArray = 0;
a_pValue->OptionalStringArray = OpcUa_Null;
}
OpcUa_FinishErrorHandling;
}
struct _OpcUa_EncodeableType Demo_StructureWithOptionalFields_EncodeableType =
{
#if !OPCUA_ENCODEABLE_OBJECT_OMIT_TYPE_NAME
"StructureWithOptionalFields",
#endif
Demo_StructureWithOptionalFieldsId,
Demo_StructureWithOptionalFields_Encoding_DefaultBinary,
#if !defined(OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING) || !OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING
Demo_StructureWithOptionalFields_Encoding_DefaultXml,
#endif
(OpcUa_StringA)Demo_NamespaceUri1,
sizeof(Demo_StructureWithOptionalFields),
(OpcUa_EncodeableObject_PfnInitialize*)Demo_StructureWithOptionalFields_Initialize,
(OpcUa_EncodeableObject_PfnClear*)Demo_StructureWithOptionalFields_Clear,
(OpcUa_EncodeableObject_PfnGetSize*)Demo_StructureWithOptionalFields_GetSize,
(OpcUa_EncodeableObject_PfnEncode*)Demo_StructureWithOptionalFields_Encode,
(OpcUa_EncodeableObject_PfnDecode*)Demo_StructureWithOptionalFields_Decode
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
,(OpcUa_EncodeableObject_PfnCompare*)Demo_StructureWithOptionalFields_Compare
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
,(OpcUa_EncodeableObject_PfnCopy*)Demo_StructureWithOptionalFields_Copy,
(OpcUa_EncodeableObject_PfnCopyTo*)Demo_StructureWithOptionalFields_CopyTo
#endif
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_UnionTest
OpcUa_Void Demo_UnionTest_Initialize(Demo_UnionTest* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
a_pValue->Type = Demo_UnionTestType_Null;
OpcUa_MemSet(&a_pValue->Value, 0, sizeof(a_pValue->Value));
}
}
OpcUa_Void Demo_UnionTest_Clear(Demo_UnionTest* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
switch (a_pValue->Type)
{
case Demo_UnionTestType_Null:
break;
case Demo_UnionTestType_Int32:
OpcUa_UnionField_Clear(Int32, Int32);
break;
case Demo_UnionTestType_String:
break;
default:
break;
}
}
}
OpcUa_StatusCode Demo_UnionTest_GetSize(Demo_UnionTest* a_pValue, OpcUa_Encoder* a_pEncoder, OpcUa_Int32* a_pSize)
{
OpcUa_Int32 iSize = 0;
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_UnionTest_GetSize");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_ReturnErrorIfArgumentNull(a_pSize);
*a_pSize = -1;
uStatus = a_pEncoder->WriteUInt32(a_pEncoder, "SwitchField", (OpcUa_UInt32*)&a_pValue->Type, &iSize);
OpcUa_GotoErrorIfBad(uStatus);
switch (a_pValue->Type)
{
case Demo_UnionTestType_Null:
break;
case Demo_UnionTestType_Int32:
OpcUa_UnionField_GetSize(Int32, Int32);
break;
case Demo_UnionTestType_String:
break;
default:
break;
}
*a_pSize = iSize;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
*a_pSize = -1;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_UnionTest_Encode(Demo_UnionTest* a_pValue, OpcUa_Encoder* a_pEncoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_UnionTest_Encode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
uStatus = a_pEncoder->WriteUInt32(a_pEncoder, "SwitchField", (OpcUa_UInt32*)&a_pValue->Type, OpcUa_Null);
OpcUa_GotoErrorIfBad(uStatus);
switch (a_pValue->Type)
{
case Demo_UnionTestType_Null:
break;
case Demo_UnionTestType_Int32:
OpcUa_UnionField_Write(Int32, Int32);
break;
case Demo_UnionTestType_String:
break;
default:
break;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_UnionTest_Decode(Demo_UnionTest* a_pValue, OpcUa_Decoder* a_pDecoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_UnionTest_Decode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pDecoder);
Demo_UnionTest_Initialize(a_pValue);
uStatus = a_pDecoder->ReadUInt32(a_pDecoder, "SwitchField", (OpcUa_UInt32*)&a_pValue->Type);
OpcUa_GotoErrorIfBad(uStatus);
switch (a_pValue->Type)
{
case Demo_UnionTestType_Null:
break;
case Demo_UnionTestType_Int32:
OpcUa_UnionField_Read(Int32, Int32);
break;
case Demo_UnionTestType_String:
break;
default:
break;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_UnionTest_Clear(a_pValue);
OpcUa_FinishErrorHandling;
}
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
OPCUA_EXPORT OpcUa_Int Demo_UnionTest_Compare(const Demo_UnionTest* a_pValue1, const Demo_UnionTest* a_pValue2)
{
if (a_pValue1 == a_pValue2)
{
return 0;
}
OpcUa_Field_Compare(UInt32, Type);
switch (a_pValue1->Type)
{
case Demo_UnionTestType_Null:
break;
case Demo_UnionTestType_Int32:
OpcUa_UnionField_Compare(Int32, Int32);
break;
case Demo_UnionTestType_String:
break;
default:
break;
}
return 0;
}
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
OPCUA_EXPORT
OpcUa_StatusCode Demo_UnionTest_Copy(
const Demo_UnionTest* a_pSource, Demo_UnionTest** a_ppCopy)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_Copy");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_ppCopy);
*a_ppCopy = OpcUa_Alloc(sizeof( Demo_UnionTest ));
OpcUa_GotoErrorIfAllocFailed(*a_ppCopy);
uStatus = Demo_UnionTest_CopyTo(a_pSource, *a_ppCopy);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppCopy != OpcUa_Null)
{
OpcUa_Free(*a_ppCopy);
*a_ppCopy = OpcUa_Null;
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_UnionTest_CopyTo(
const Demo_UnionTest* a_pSource, Demo_UnionTest* a_pDestination)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_CopyTo");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_pDestination);
Demo_UnionTest_Initialize(a_pDestination);
OpcUa_Field_CopyToScalar(UInt32, Type);
switch (a_pSource->Type)
{
case Demo_UnionTestType_Null:
break;
case Demo_UnionTestType_Int32:
OpcUa_UnionField_CopyToScalar(Int32, Int32);
break;
case Demo_UnionTestType_String:
break;
default:
break;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_UnionTest_Clear(a_pDestination);
OpcUa_FinishErrorHandling;
}
#endif
OPCUA_EXPORT
OpcUa_StatusCode Demo_UnionTest_ArrayFromVariant(
OpcUa_Variant* a_pVariant, OpcUa_Int32 *a_pNoOfValues, Demo_UnionTest **a_ppValues, OpcUa_Boolean a_bDetach)
{
OpcUa_Int32 i;
Demo_UnionTest *pValue;
Demo_UnionTest *pValues = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_ArrayFromVariant");
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++)
{
|| !a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type
|| a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type->TypeId != Demo_UnionTestId)
{
return OpcUa_BadInvalidArgument;
}
}
*a_pNoOfValues = 0;
if (a_pVariant->
Value.Array.Length > 0)
{
pValues = (Demo_UnionTest*) OpcUa_Alloc(a_pVariant->
Value.Array.Length *
sizeof(Demo_UnionTest));
OpcUa_GotoErrorIfAllocFailed(pValues);
OpcUa_MemSet(pValues, 0, a_pVariant->
Value.Array.Length *
sizeof(Demo_UnionTest));
for (i=0; i<a_pVariant->
Value.Array.Length; i++)
{
pValue = (Demo_UnionTest*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object;
if (a_bDetach)
{
pValues[i] = *pValue;
Demo_UnionTest_Initialize((Demo_UnionTest*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object);
OpcUa_ExtensionObject_Clear(&a_pVariant->
Value.Array.Value.ExtensionObjectArray[i]);
}
else
{
uStatus = Demo_UnionTest_CopyTo(pValue, &pValues[i]);
OpcUa_GotoErrorIfBad(uStatus);
}
}
*a_ppValues = pValues;
*a_pNoOfValues = a_pVariant->
Value.Array.Length;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (pValues)
{
for (i = 0; i < a_pVariant->
Value.Array.Length; i++)
{
Demo_UnionTest_Clear(&pValues[i]);
}
OpcUa_Free(pValues);
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_UnionTest_ArrayToVariant(OpcUa_Int32 *a_pNoOfValues, Demo_UnionTest **a_ppValues,
OpcUa_Variant* a_pVariant, OpcUa_Boolean a_bAttach)
{
OpcUa_Int32 i;
Demo_UnionTest *pValue;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_ArrayToVariant");
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;
if (*a_pNoOfValues > 0)
{
OpcUa_ReturnErrorIfAllocFailed(a_pVariant->
Value.Array.Value.ExtensionObjectArray);
a_pVariant->
Value.Array.Length = *a_pNoOfValues;
for (i=0; i<*a_pNoOfValues; i++)
{
uStatus = OpcUa_EncodeableObject_CreateExtension(&Demo_UnionTest_EncodeableType, &a_pVariant->
Value.Array.Value.ExtensionObjectArray[i], (OpcUa_Void**)&pValue);
OpcUa_GotoErrorIfBad(uStatus);
if (a_bAttach)
{
OpcUa_MemCpy(pValue, sizeof (Demo_UnionTest), (*a_ppValues)+i, sizeof(Demo_UnionTest));
}
else
{
uStatus = Demo_UnionTest_CopyTo(&(*a_ppValues)[i], pValue);
OpcUa_GotoErrorIfBad(uStatus);
}
}
if (a_bAttach)
{
OpcUa_Free(*a_ppValues);
*a_pNoOfValues = 0;
*a_ppValues = OpcUa_Null;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_Variant_Clear(a_pVariant);
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_UnionTest_Get_Int32(
const Demo_UnionTest *a_pValue, OpcUa_Int32 *a_pInt32)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_Get_Int32");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pInt32);
if (a_pValue->Type == Demo_UnionTestType_Int32)
{
*a_pInt32 = a_pValue->Value.Int32;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_UnionTest_Set_Int32(Demo_UnionTest *a_pValue, OpcUa_Int32 *a_pInt32)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_Set_Int32");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pInt32);
Demo_UnionTest_Clear(a_pValue);
a_pValue->Type = Demo_UnionTestType_Int32;
a_pValue->Value.Int32 = *a_pInt32;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
a_pValue->Type = Demo_UnionTestType_Null;
OpcUa_FinishErrorHandling;
}
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_Get_String");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pString);
if (a_pValue->Type == Demo_UnionTestType_String)
{
uStatus = OpcUa_String_CopyTo(&a_pValue->Value.String, a_pString);
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_UnionTest_Set_String");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pString);
Demo_UnionTest_Clear(a_pValue);
a_pValue->Type = Demo_UnionTestType_String;
uStatus = OpcUa_String_CopyTo(a_pString, &a_pValue->Value.String);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
a_pValue->Type = Demo_UnionTestType_Null;
OpcUa_FinishErrorHandling;
}
struct _OpcUa_EncodeableType Demo_UnionTest_EncodeableType =
{
#if !OPCUA_ENCODEABLE_OBJECT_OMIT_TYPE_NAME
"UnionTest",
#endif
Demo_UnionTestId,
Demo_UnionTest_Encoding_DefaultBinary,
#if !defined(OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING) || !OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING
Demo_UnionTest_Encoding_DefaultXml,
#endif
(OpcUa_StringA)Demo_NamespaceUri1,
sizeof(Demo_UnionTest),
(OpcUa_EncodeableObject_PfnInitialize*)Demo_UnionTest_Initialize,
(OpcUa_EncodeableObject_PfnClear*)Demo_UnionTest_Clear,
(OpcUa_EncodeableObject_PfnGetSize*)Demo_UnionTest_GetSize,
(OpcUa_EncodeableObject_PfnEncode*)Demo_UnionTest_Encode,
(OpcUa_EncodeableObject_PfnDecode*)Demo_UnionTest_Decode
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
,(OpcUa_EncodeableObject_PfnCompare*)Demo_UnionTest_Compare
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
,(OpcUa_EncodeableObject_PfnCopy*)Demo_UnionTest_Copy,
(OpcUa_EncodeableObject_PfnCopyTo*)Demo_UnionTest_CopyTo
#endif
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_Vector
OpcUa_Void Demo_Vector_Initialize(Demo_Vector* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Initialize(Double, X);
OpcUa_Field_Initialize(Double, Y);
OpcUa_Field_Initialize(Double, Z);
}
}
OpcUa_Void Demo_Vector_Clear(Demo_Vector* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Clear(Double, X);
OpcUa_Field_Clear(Double, Y);
OpcUa_Field_Clear(Double, Z);
}
}
OpcUa_StatusCode Demo_Vector_GetSize(Demo_Vector* a_pValue, OpcUa_Encoder* a_pEncoder, OpcUa_Int32* a_pSize)
{
OpcUa_Int32 iSize = 0;
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_Vector_GetSize");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_ReturnErrorIfArgumentNull(a_pSize);
*a_pSize = -1;
OpcUa_Field_GetSize(Double, X);
OpcUa_Field_GetSize(Double, Y);
OpcUa_Field_GetSize(Double, Z);
*a_pSize = iSize;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
*a_pSize = -1;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_Vector_Encode(Demo_Vector* a_pValue, OpcUa_Encoder* a_pEncoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_Vector_Encode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_Field_Write(Double, X);
OpcUa_Field_Write(Double, Y);
OpcUa_Field_Write(Double, Z);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_Vector_Decode(Demo_Vector* a_pValue, OpcUa_Decoder* a_pDecoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_Vector_Decode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pDecoder);
Demo_Vector_Initialize(a_pValue);
OpcUa_Field_Read(Double, X);
OpcUa_Field_Read(Double, Y);
OpcUa_Field_Read(Double, Z);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_Vector_Clear(a_pValue);
OpcUa_FinishErrorHandling;
}
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
OPCUA_EXPORT OpcUa_Int Demo_Vector_Compare(const Demo_Vector* a_pValue1, const Demo_Vector* a_pValue2)
{
if (a_pValue1 == a_pValue2)
{
return 0;
}
OpcUa_Field_Compare(Double, X);
OpcUa_Field_Compare(Double, Y);
OpcUa_Field_Compare(Double, Z);
return 0;
}
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
OPCUA_EXPORT
OpcUa_StatusCode Demo_Vector_Copy(
const Demo_Vector* a_pSource, Demo_Vector** a_ppCopy)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_Vector_Copy");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_ppCopy);
*a_ppCopy = OpcUa_Alloc(sizeof( Demo_Vector ));
OpcUa_GotoErrorIfAllocFailed(*a_ppCopy);
uStatus = Demo_Vector_CopyTo(a_pSource, *a_ppCopy);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppCopy != OpcUa_Null)
{
OpcUa_Free(*a_ppCopy);
*a_ppCopy = OpcUa_Null;
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_Vector_CopyTo(
const Demo_Vector* a_pSource, Demo_Vector* a_pDestination)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_Vector_CopyTo");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_pDestination);
Demo_Vector_Initialize(a_pDestination);
OpcUa_Field_CopyToScalar(Double, X);
OpcUa_Field_CopyToScalar(Double, Y);
OpcUa_Field_CopyToScalar(Double, Z);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_Vector_Clear(a_pDestination);
OpcUa_FinishErrorHandling;
}
#endif
OPCUA_EXPORT
OpcUa_StatusCode Demo_Vector_ArrayFromVariant(
OpcUa_Variant* a_pVariant, OpcUa_Int32 *a_pNoOfValues, Demo_Vector **a_ppValues, OpcUa_Boolean a_bDetach)
{
OpcUa_Int32 i;
Demo_Vector *pValue;
Demo_Vector *pValues = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_Vector_ArrayFromVariant");
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++)
{
|| !a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type
|| a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type->TypeId != Demo_VectorId)
{
return OpcUa_BadInvalidArgument;
}
}
*a_pNoOfValues = 0;
if (a_pVariant->
Value.Array.Length > 0)
{
pValues = (Demo_Vector*) OpcUa_Alloc(a_pVariant->
Value.Array.Length *
sizeof(Demo_Vector));
OpcUa_GotoErrorIfAllocFailed(pValues);
OpcUa_MemSet(pValues, 0, a_pVariant->
Value.Array.Length *
sizeof(Demo_Vector));
for (i=0; i<a_pVariant->
Value.Array.Length; i++)
{
pValue = (Demo_Vector*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object;
if (a_bDetach)
{
pValues[i] = *pValue;
Demo_Vector_Initialize((Demo_Vector*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object);
OpcUa_ExtensionObject_Clear(&a_pVariant->
Value.Array.Value.ExtensionObjectArray[i]);
}
else
{
uStatus = Demo_Vector_CopyTo(pValue, &pValues[i]);
OpcUa_GotoErrorIfBad(uStatus);
}
}
*a_ppValues = pValues;
*a_pNoOfValues = a_pVariant->
Value.Array.Length;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (pValues)
{
for (i = 0; i < a_pVariant->
Value.Array.Length; i++)
{
Demo_Vector_Clear(&pValues[i]);
}
OpcUa_Free(pValues);
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_Vector_ArrayToVariant(OpcUa_Int32 *a_pNoOfValues, Demo_Vector **a_ppValues,
OpcUa_Variant* a_pVariant, OpcUa_Boolean a_bAttach)
{
OpcUa_Int32 i;
Demo_Vector *pValue;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_Vector_ArrayToVariant");
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;
if (*a_pNoOfValues > 0)
{
OpcUa_ReturnErrorIfAllocFailed(a_pVariant->
Value.Array.Value.ExtensionObjectArray);
a_pVariant->
Value.Array.Length = *a_pNoOfValues;
for (i=0; i<*a_pNoOfValues; i++)
{
uStatus = OpcUa_EncodeableObject_CreateExtension(&Demo_Vector_EncodeableType, &a_pVariant->
Value.Array.Value.ExtensionObjectArray[i], (OpcUa_Void**)&pValue);
OpcUa_GotoErrorIfBad(uStatus);
if (a_bAttach)
{
OpcUa_MemCpy(pValue, sizeof (Demo_Vector), (*a_ppValues)+i, sizeof(Demo_Vector));
}
else
{
uStatus = Demo_Vector_CopyTo(&(*a_ppValues)[i], pValue);
OpcUa_GotoErrorIfBad(uStatus);
}
}
if (a_bAttach)
{
OpcUa_Free(*a_ppValues);
*a_pNoOfValues = 0;
*a_ppValues = OpcUa_Null;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_Variant_Clear(a_pVariant);
OpcUa_FinishErrorHandling;
}
struct _OpcUa_EncodeableType Demo_Vector_EncodeableType =
{
#if !OPCUA_ENCODEABLE_OBJECT_OMIT_TYPE_NAME
"Vector",
#endif
Demo_VectorId,
Demo_Vector_Encoding_DefaultBinary,
#if !defined(OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING) || !OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING
Demo_Vector_Encoding_DefaultXml,
#endif
(OpcUa_StringA)Demo_NamespaceUri1,
sizeof(Demo_Vector),
(OpcUa_EncodeableObject_PfnInitialize*)Demo_Vector_Initialize,
(OpcUa_EncodeableObject_PfnClear*)Demo_Vector_Clear,
(OpcUa_EncodeableObject_PfnGetSize*)Demo_Vector_GetSize,
(OpcUa_EncodeableObject_PfnEncode*)Demo_Vector_Encode,
(OpcUa_EncodeableObject_PfnDecode*)Demo_Vector_Decode
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
,(OpcUa_EncodeableObject_PfnCompare*)Demo_Vector_Compare
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
,(OpcUa_EncodeableObject_PfnCopy*)Demo_Vector_Copy,
(OpcUa_EncodeableObject_PfnCopyTo*)Demo_Vector_CopyTo
#endif
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_WorkOrderStatusType
OpcUa_Void Demo_WorkOrderStatusType_Initialize(Demo_WorkOrderStatusType* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Initialize(
String, Actor);
OpcUa_Field_Initialize(DateTime, Timestamp);
OpcUa_Field_Initialize(LocalizedText, Comment);
}
}
OpcUa_Void Demo_WorkOrderStatusType_Clear(Demo_WorkOrderStatusType* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Clear(
String, Actor);
OpcUa_Field_Clear(DateTime, Timestamp);
OpcUa_Field_Clear(LocalizedText, Comment);
}
}
OpcUa_StatusCode Demo_WorkOrderStatusType_GetSize(Demo_WorkOrderStatusType* a_pValue, OpcUa_Encoder* a_pEncoder, OpcUa_Int32* a_pSize)
{
OpcUa_Int32 iSize = 0;
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_WorkOrderStatusType_GetSize");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_ReturnErrorIfArgumentNull(a_pSize);
*a_pSize = -1;
OpcUa_Field_GetSize(
String, Actor);
OpcUa_Field_GetSize(DateTime, Timestamp);
OpcUa_Field_GetSize(LocalizedText, Comment);
*a_pSize = iSize;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
*a_pSize = -1;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_WorkOrderStatusType_Encode(Demo_WorkOrderStatusType* a_pValue, OpcUa_Encoder* a_pEncoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_WorkOrderStatusType_Encode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_Field_Write(
String, Actor);
OpcUa_Field_Write(DateTime, Timestamp);
OpcUa_Field_Write(LocalizedText, Comment);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_WorkOrderStatusType_Decode(Demo_WorkOrderStatusType* a_pValue, OpcUa_Decoder* a_pDecoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_WorkOrderStatusType_Decode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pDecoder);
Demo_WorkOrderStatusType_Initialize(a_pValue);
OpcUa_Field_Read(
String, Actor);
OpcUa_Field_Read(DateTime, Timestamp);
OpcUa_Field_Read(LocalizedText, Comment);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_WorkOrderStatusType_Clear(a_pValue);
OpcUa_FinishErrorHandling;
}
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
OPCUA_EXPORT OpcUa_Int Demo_WorkOrderStatusType_Compare(const Demo_WorkOrderStatusType* a_pValue1, const Demo_WorkOrderStatusType* a_pValue2)
{
if (a_pValue1 == a_pValue2)
{
return 0;
}
OpcUa_Field_Compare(
String, Actor);
OpcUa_Field_Compare(DateTime, Timestamp);
OpcUa_Field_Compare(LocalizedText, Comment);
return 0;
}
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderStatusType_Copy(
const Demo_WorkOrderStatusType* a_pSource, Demo_WorkOrderStatusType** a_ppCopy)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderStatusType_Copy");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_ppCopy);
*a_ppCopy = OpcUa_Alloc(sizeof( Demo_WorkOrderStatusType ));
OpcUa_GotoErrorIfAllocFailed(*a_ppCopy);
uStatus = Demo_WorkOrderStatusType_CopyTo(a_pSource, *a_ppCopy);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppCopy != OpcUa_Null)
{
OpcUa_Free(*a_ppCopy);
*a_ppCopy = OpcUa_Null;
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderStatusType_CopyTo(
const Demo_WorkOrderStatusType* a_pSource, Demo_WorkOrderStatusType* a_pDestination)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderStatusType_CopyTo");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_pDestination);
Demo_WorkOrderStatusType_Initialize(a_pDestination);
OpcUa_Field_CopyTo(
String, Actor);
OpcUa_Field_CopyToScalar(DateTime, Timestamp);
OpcUa_Field_CopyTo(LocalizedText, Comment);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_WorkOrderStatusType_Clear(a_pDestination);
OpcUa_FinishErrorHandling;
}
#endif
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderStatusType_ArrayFromVariant(
OpcUa_Variant* a_pVariant, OpcUa_Int32 *a_pNoOfValues, Demo_WorkOrderStatusType **a_ppValues, OpcUa_Boolean a_bDetach)
{
OpcUa_Int32 i;
Demo_WorkOrderStatusType *pValue;
Demo_WorkOrderStatusType *pValues = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderStatusType_ArrayFromVariant");
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++)
{
|| !a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type
|| a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type->TypeId != Demo_WorkOrderStatusTypeId)
{
return OpcUa_BadInvalidArgument;
}
}
*a_pNoOfValues = 0;
if (a_pVariant->
Value.Array.Length > 0)
{
pValues = (Demo_WorkOrderStatusType*) OpcUa_Alloc(a_pVariant->
Value.Array.Length *
sizeof(Demo_WorkOrderStatusType));
OpcUa_GotoErrorIfAllocFailed(pValues);
OpcUa_MemSet(pValues, 0, a_pVariant->
Value.Array.Length *
sizeof(Demo_WorkOrderStatusType));
for (i=0; i<a_pVariant->
Value.Array.Length; i++)
{
pValue = (Demo_WorkOrderStatusType*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object;
if (a_bDetach)
{
pValues[i] = *pValue;
Demo_WorkOrderStatusType_Initialize((Demo_WorkOrderStatusType*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object);
OpcUa_ExtensionObject_Clear(&a_pVariant->
Value.Array.Value.ExtensionObjectArray[i]);
}
else
{
uStatus = Demo_WorkOrderStatusType_CopyTo(pValue, &pValues[i]);
OpcUa_GotoErrorIfBad(uStatus);
}
}
*a_ppValues = pValues;
*a_pNoOfValues = a_pVariant->
Value.Array.Length;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (pValues)
{
for (i = 0; i < a_pVariant->
Value.Array.Length; i++)
{
Demo_WorkOrderStatusType_Clear(&pValues[i]);
}
OpcUa_Free(pValues);
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderStatusType_ArrayToVariant(OpcUa_Int32 *a_pNoOfValues, Demo_WorkOrderStatusType **a_ppValues,
OpcUa_Variant* a_pVariant, OpcUa_Boolean a_bAttach)
{
OpcUa_Int32 i;
Demo_WorkOrderStatusType *pValue;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderStatusType_ArrayToVariant");
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;
if (*a_pNoOfValues > 0)
{
OpcUa_ReturnErrorIfAllocFailed(a_pVariant->
Value.Array.Value.ExtensionObjectArray);
a_pVariant->
Value.Array.Length = *a_pNoOfValues;
for (i=0; i<*a_pNoOfValues; i++)
{
uStatus = OpcUa_EncodeableObject_CreateExtension(&Demo_WorkOrderStatusType_EncodeableType, &a_pVariant->
Value.Array.Value.ExtensionObjectArray[i], (OpcUa_Void**)&pValue);
OpcUa_GotoErrorIfBad(uStatus);
if (a_bAttach)
{
OpcUa_MemCpy(pValue, sizeof (Demo_WorkOrderStatusType), (*a_ppValues)+i, sizeof(Demo_WorkOrderStatusType));
}
else
{
uStatus = Demo_WorkOrderStatusType_CopyTo(&(*a_ppValues)[i], pValue);
OpcUa_GotoErrorIfBad(uStatus);
}
}
if (a_bAttach)
{
OpcUa_Free(*a_ppValues);
*a_pNoOfValues = 0;
*a_ppValues = OpcUa_Null;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_Variant_Clear(a_pVariant);
OpcUa_FinishErrorHandling;
}
struct _OpcUa_EncodeableType Demo_WorkOrderStatusType_EncodeableType =
{
#if !OPCUA_ENCODEABLE_OBJECT_OMIT_TYPE_NAME
"WorkOrderStatusType",
#endif
Demo_WorkOrderStatusTypeId,
Demo_WorkOrderStatusType_Encoding_DefaultBinary,
#if !defined(OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING) || !OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING
Demo_WorkOrderStatusType_Encoding_DefaultXml,
#endif
(OpcUa_StringA)Demo_NamespaceUri1,
sizeof(Demo_WorkOrderStatusType),
(OpcUa_EncodeableObject_PfnInitialize*)Demo_WorkOrderStatusType_Initialize,
(OpcUa_EncodeableObject_PfnClear*)Demo_WorkOrderStatusType_Clear,
(OpcUa_EncodeableObject_PfnGetSize*)Demo_WorkOrderStatusType_GetSize,
(OpcUa_EncodeableObject_PfnEncode*)Demo_WorkOrderStatusType_Encode,
(OpcUa_EncodeableObject_PfnDecode*)Demo_WorkOrderStatusType_Decode
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
,(OpcUa_EncodeableObject_PfnCompare*)Demo_WorkOrderStatusType_Compare
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
,(OpcUa_EncodeableObject_PfnCopy*)Demo_WorkOrderStatusType_Copy,
(OpcUa_EncodeableObject_PfnCopyTo*)Demo_WorkOrderStatusType_CopyTo
#endif
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_WorkOrderType
OpcUa_Void Demo_WorkOrderType_Initialize(Demo_WorkOrderType* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Initialize(
Guid, ID);
OpcUa_Field_Initialize(
String, AssetID);
OpcUa_Field_Initialize(DateTime, StartTime);
OpcUa_Field_InitializeEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
}
}
OpcUa_Void Demo_WorkOrderType_Clear(Demo_WorkOrderType* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_Field_Clear(
Guid, ID);
OpcUa_Field_Clear(
String, AssetID);
OpcUa_Field_Clear(DateTime, StartTime);
OpcUa_Field_ClearEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
}
}
OpcUa_StatusCode Demo_WorkOrderType_GetSize(Demo_WorkOrderType* a_pValue, OpcUa_Encoder* a_pEncoder, OpcUa_Int32* a_pSize)
{
OpcUa_Int32 iSize = 0;
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_WorkOrderType_GetSize");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_ReturnErrorIfArgumentNull(a_pSize);
*a_pSize = -1;
OpcUa_Field_GetSize(
Guid, ID);
OpcUa_Field_GetSize(
String, AssetID);
OpcUa_Field_GetSize(DateTime, StartTime);
OpcUa_Field_GetSizeEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
*a_pSize = iSize;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
*a_pSize = -1;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_WorkOrderType_Encode(Demo_WorkOrderType* a_pValue, OpcUa_Encoder* a_pEncoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_WorkOrderType_Encode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pEncoder);
OpcUa_Field_Write(
Guid, ID);
OpcUa_Field_Write(
String, AssetID);
OpcUa_Field_Write(DateTime, StartTime);
OpcUa_Field_WriteEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode Demo_WorkOrderType_Decode(Demo_WorkOrderType* a_pValue, OpcUa_Decoder* a_pDecoder)
{
OpcUa_InitializeStatus(OpcUa_Module_Serializer, "Demo_WorkOrderType_Decode");
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
OpcUa_ReturnErrorIfArgumentNull(a_pDecoder);
Demo_WorkOrderType_Initialize(a_pValue);
OpcUa_Field_Read(
Guid, ID);
OpcUa_Field_Read(
String, AssetID);
OpcUa_Field_Read(DateTime, StartTime);
OpcUa_Field_ReadEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_WorkOrderType_Clear(a_pValue);
OpcUa_FinishErrorHandling;
}
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
OPCUA_EXPORT OpcUa_Int Demo_WorkOrderType_Compare(const Demo_WorkOrderType* a_pValue1, const Demo_WorkOrderType* a_pValue2)
{
if (a_pValue1 == a_pValue2)
{
return 0;
}
OpcUa_Field_Compare(
Guid, ID);
OpcUa_Field_Compare(
String, AssetID);
OpcUa_Field_Compare(DateTime, StartTime);
OpcUa_Field_CompareEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
return 0;
}
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderType_Copy(
const Demo_WorkOrderType* a_pSource, Demo_WorkOrderType** a_ppCopy)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderType_Copy");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_ppCopy);
*a_ppCopy = OpcUa_Alloc(sizeof( Demo_WorkOrderType ));
OpcUa_GotoErrorIfAllocFailed(*a_ppCopy);
uStatus = Demo_WorkOrderType_CopyTo(a_pSource, *a_ppCopy);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppCopy != OpcUa_Null)
{
OpcUa_Free(*a_ppCopy);
*a_ppCopy = OpcUa_Null;
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderType_CopyTo(
const Demo_WorkOrderType* a_pSource, Demo_WorkOrderType* a_pDestination)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderType_CopyTo");
OpcUa_ReturnErrorIfArgumentNull(a_pSource);
OpcUa_ReturnErrorIfArgumentNull(a_pDestination);
Demo_WorkOrderType_Initialize(a_pDestination);
OpcUa_Field_CopyTo(
Guid, ID);
OpcUa_Field_CopyTo(
String, AssetID);
OpcUa_Field_CopyToScalar(DateTime, StartTime);
OpcUa_Field_CopyEncodeableArray(Demo_WorkOrderStatusType, StatusComments);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_WorkOrderType_Clear(a_pDestination);
OpcUa_FinishErrorHandling;
}
#endif
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderType_ArrayFromVariant(
OpcUa_Variant* a_pVariant, OpcUa_Int32 *a_pNoOfValues, Demo_WorkOrderType **a_ppValues, OpcUa_Boolean a_bDetach)
{
OpcUa_Int32 i;
Demo_WorkOrderType *pValue;
Demo_WorkOrderType *pValues = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderType_ArrayFromVariant");
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++)
{
|| !a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type
|| a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Type->TypeId != Demo_WorkOrderTypeId)
{
return OpcUa_BadInvalidArgument;
}
}
*a_pNoOfValues = 0;
if (a_pVariant->
Value.Array.Length > 0)
{
pValues = (Demo_WorkOrderType*) OpcUa_Alloc(a_pVariant->
Value.Array.Length *
sizeof(Demo_WorkOrderType));
OpcUa_GotoErrorIfAllocFailed(pValues);
OpcUa_MemSet(pValues, 0, a_pVariant->
Value.Array.Length *
sizeof(Demo_WorkOrderType));
for (i=0; i<a_pVariant->
Value.Array.Length; i++)
{
pValue = (Demo_WorkOrderType*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object;
if (a_bDetach)
{
pValues[i] = *pValue;
Demo_WorkOrderType_Initialize((Demo_WorkOrderType*) a_pVariant->
Value.Array.Value.ExtensionObjectArray[i].Body.EncodeableObject.Object);
OpcUa_ExtensionObject_Clear(&a_pVariant->
Value.Array.Value.ExtensionObjectArray[i]);
}
else
{
uStatus = Demo_WorkOrderType_CopyTo(pValue, &pValues[i]);
OpcUa_GotoErrorIfBad(uStatus);
}
}
*a_ppValues = pValues;
*a_pNoOfValues = a_pVariant->
Value.Array.Length;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (pValues)
{
for (i = 0; i < a_pVariant->
Value.Array.Length; i++)
{
Demo_WorkOrderType_Clear(&pValues[i]);
}
OpcUa_Free(pValues);
}
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_WorkOrderType_ArrayToVariant(OpcUa_Int32 *a_pNoOfValues, Demo_WorkOrderType **a_ppValues,
OpcUa_Variant* a_pVariant, OpcUa_Boolean a_bAttach)
{
OpcUa_Int32 i;
Demo_WorkOrderType *pValue;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_WorkOrderType_ArrayToVariant");
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;
if (*a_pNoOfValues > 0)
{
OpcUa_ReturnErrorIfAllocFailed(a_pVariant->
Value.Array.Value.ExtensionObjectArray);
a_pVariant->
Value.Array.Length = *a_pNoOfValues;
for (i=0; i<*a_pNoOfValues; i++)
{
uStatus = OpcUa_EncodeableObject_CreateExtension(&Demo_WorkOrderType_EncodeableType, &a_pVariant->
Value.Array.Value.ExtensionObjectArray[i], (OpcUa_Void**)&pValue);
OpcUa_GotoErrorIfBad(uStatus);
if (a_bAttach)
{
OpcUa_MemCpy(pValue, sizeof (Demo_WorkOrderType), (*a_ppValues)+i, sizeof(Demo_WorkOrderType));
}
else
{
uStatus = Demo_WorkOrderType_CopyTo(&(*a_ppValues)[i], pValue);
OpcUa_GotoErrorIfBad(uStatus);
}
}
if (a_bAttach)
{
OpcUa_Free(*a_ppValues);
*a_pNoOfValues = 0;
*a_ppValues = OpcUa_Null;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_Variant_Clear(a_pVariant);
OpcUa_FinishErrorHandling;
}
struct _OpcUa_EncodeableType Demo_WorkOrderType_EncodeableType =
{
#if !OPCUA_ENCODEABLE_OBJECT_OMIT_TYPE_NAME
"WorkOrderType",
#endif
Demo_WorkOrderTypeId,
Demo_WorkOrderType_Encoding_DefaultBinary,
#if !defined(OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING) || !OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING
Demo_WorkOrderType_Encoding_DefaultXml,
#endif
(OpcUa_StringA)Demo_NamespaceUri1,
sizeof(Demo_WorkOrderType),
(OpcUa_EncodeableObject_PfnInitialize*)Demo_WorkOrderType_Initialize,
(OpcUa_EncodeableObject_PfnClear*)Demo_WorkOrderType_Clear,
(OpcUa_EncodeableObject_PfnGetSize*)Demo_WorkOrderType_GetSize,
(OpcUa_EncodeableObject_PfnEncode*)Demo_WorkOrderType_Encode,
(OpcUa_EncodeableObject_PfnDecode*)Demo_WorkOrderType_Decode
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
,(OpcUa_EncodeableObject_PfnCompare*)Demo_WorkOrderType_Compare
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
,(OpcUa_EncodeableObject_PfnCopy*)Demo_WorkOrderType_Copy,
(OpcUa_EncodeableObject_PfnCopyTo*)Demo_WorkOrderType_CopyTo
#endif
};
#endif
#ifndef OPCUA_EXCLUDE_Demo_AccessRights
struct _OpcUa_EncodeableType Demo_AccessRights_EncodeableType =
{
#if !OPCUA_ENCODEABLE_OBJECT_OMIT_TYPE_NAME
"AccessRights",
#endif
Demo_AccessRightsId,
Demo_AccessRights_Encoding_DefaultBinary,
#if !defined(OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING) || !OPCUA_ENCODEABLE_OBJECT_OMIT_XML_ENCODING
Demo_AccessRights_Encoding_DefaultXml,
#endif
(OpcUa_StringA)Demo_NamespaceUri1,
sizeof(Demo_AccessRights),
(OpcUa_EncodeableObject_PfnInitialize*)OpcUa_OptionSet_Initialize,
(OpcUa_EncodeableObject_PfnClear*)OpcUa_OptionSet_Clear,
(OpcUa_EncodeableObject_PfnGetSize*)OpcUa_OptionSet_GetSize,
(OpcUa_EncodeableObject_PfnEncode*)OpcUa_OptionSet_Encode,
(OpcUa_EncodeableObject_PfnDecode*)OpcUa_OptionSet_Decode
#if OPCUA_ENCODEABLE_OBJECT_COMPARE_SUPPORTED
,(OpcUa_EncodeableObject_PfnCompare*)OpcUa_OptionSet_Compare
#endif
#if OPCUA_ENCODEABLE_OBJECT_COPY_SUPPORTED
,(OpcUa_EncodeableObject_PfnCopy*)OpcUa_OptionSet_Copy,
(OpcUa_EncodeableObject_PfnCopyTo*)OpcUa_OptionSet_CopyTo
#endif
};
static const OpcUa_Int32 g_Demo_AccessRights_NoOfBytes = 1;
static const OpcUa_Byte g_Demo_AccessRights_ValidBits = 7;
OPCUA_EXPORT
OpcUa_StatusCode Demo_AccessRights_CreateDefaultValue(Demo_AccessRights* pValue)
{
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_AccessRights_CreateDefaultValue");
OpcUa_ReturnErrorIfArgumentNull(pValue);
Demo_AccessRights_Initialize(pValue);
pValue->Value.Data = OpcUa_Alloc(g_Demo_AccessRights_NoOfBytes * sizeof(OpcUa_Byte));
OpcUa_GotoErrorIfAllocFailed(pValue->Value.Data);
OpcUa_MemSet(pValue->Value.Data, 0, g_Demo_AccessRights_NoOfBytes);
pValue->Value.Length = g_Demo_AccessRights_NoOfBytes;
pValue->ValidBits.Data = OpcUa_Alloc(g_Demo_AccessRights_NoOfBytes * sizeof(OpcUa_Byte));
OpcUa_GotoErrorIfAllocFailed(pValue->ValidBits.Data);
OpcUa_MemSet(pValue->ValidBits.Data, 255, g_Demo_AccessRights_NoOfBytes);
pValue->ValidBits.Data[g_Demo_AccessRights_NoOfBytes-1] = g_Demo_AccessRights_ValidBits;
pValue->ValidBits.Length = g_Demo_AccessRights_NoOfBytes;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_AccessRights_Clear(pValue);
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_AccessRights_SetBits(Demo_AccessRights* pValue, Demo_AccessRightsMask mask)
{
OpcUa_Int32 i;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_AccessRights_SetBits");
OpcUa_ReturnErrorIfArgumentNull(pValue);
for (i = 0; i < pValue->Value.Length && i < pValue->ValidBits.Length; i++)
{
if (i < g_Demo_AccessRights_NoOfBytes - 1)
{
pValue->Value.Data[i] = (OpcUa_Byte)(mask >> (i * 8));
}
else
{
pValue->Value.Data[i] = (OpcUa_Byte)(mask >> (i * 8)) & g_Demo_AccessRights_ValidBits;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_AccessRights_SetValidBits(Demo_AccessRights* pValue, Demo_AccessRightsMask mask)
{
OpcUa_Int32 i;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_AccessRights_SetValidBits");
OpcUa_ReturnErrorIfArgumentNull(pValue);
for (i = 0; i < pValue->ValidBits.Length; i++)
{
if (i < g_Demo_AccessRights_NoOfBytes - 1)
{
pValue->ValidBits.Data[i] = (OpcUa_Byte)(mask >> (i * 8));
}
else
{
pValue->ValidBits.Data[i] = (OpcUa_Byte)(mask >> (i * 8)) & g_Demo_AccessRights_ValidBits;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_AccessRights_SetBit(Demo_AccessRights* pValue, Demo_AccessRightsBits bit, OpcUa_Boolean bitValue)
{
OpcUa_Int32 iByte = bit / 8;
OpcUa_Int32 iBitOffset = bit % 8;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_AccessRights_SetBit");
OpcUa_ReturnErrorIfArgumentNull(pValue);
OpcUa_GotoErrorIfTrue(bit >= 3, OpcUa_BadInvalidArgument);
if (bitValue != OpcUa_False)
{
pValue->Value.Data[iByte] |= 1 << iBitOffset;
}
else
{
pValue->Value.Data[iByte] &= ~(1 << iBitOffset);
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_AccessRights_SetValidBit(Demo_AccessRights* pValue, Demo_AccessRightsBits bit, OpcUa_Boolean bitValue)
{
OpcUa_Int32 iByte = bit / 8;
OpcUa_Int32 iBitOffset = bit % 8;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_AccessRights_SetValidBit");
OpcUa_ReturnErrorIfArgumentNull(pValue);
OpcUa_GotoErrorIfTrue(bit >= 3, OpcUa_BadInvalidArgument);
if (bitValue != OpcUa_False)
{
pValue->ValidBits.Data[iByte] |= 1 << iBitOffset;
}
else
{
pValue->ValidBits.Data[iByte] &= ~(1 << iBitOffset);
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OPCUA_EXPORT
OpcUa_StatusCode Demo_AccessRights_Apply(Demo_AccessRights* pSource, Demo_AccessRights* pTarget)
{
OpcUa_Int32 i;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "Demo_AccessRights_Apply");
OpcUa_ReturnErrorIfArgumentNull(pSource);
OpcUa_ReturnErrorIfArgumentNull(pTarget);
OpcUa_GotoErrorIfTrue(pSource->Value.Length != pSource->ValidBits.Length ||
pTarget->Value.Length != pTarget->ValidBits.Length ||
pSource->Value.Length > pTarget->Value.Length, OpcUa_BadInvalidArgument);
for (i = 0; i < pSource->Value.Length && i < pTarget->Value.Length; i++)
{
OpcUa_Byte srcBits = pSource->Value.Data[i] & pSource->ValidBits.Data[i];
OpcUa_Byte tgtBits = pTarget->Value.Data[i] & ~(pSource->ValidBits.Data[i]);
pTarget->Value.Data[i] = (srcBits | tgtBits) & pTarget->ValidBits.Data[i];
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
#endif
static OpcUa_EncodeableType* g_Demo_KnownEncodeableTypes1[] =
{
#ifndef OPCUA_EXCLUDE_Demo_AccessRights
&Demo_AccessRights_EncodeableType,
#endif
#ifndef OPCUA_EXCLUDE_Demo_StructureWithOptionalFields
&Demo_StructureWithOptionalFields_EncodeableType,
#endif
#ifndef OPCUA_EXCLUDE_Demo_UnionTest
&Demo_UnionTest_EncodeableType,
#endif
#ifndef OPCUA_EXCLUDE_Demo_Vector
&Demo_Vector_EncodeableType,
#endif
#ifndef OPCUA_EXCLUDE_Demo_WorkOrderStatusType
&Demo_WorkOrderStatusType_EncodeableType,
#endif
#ifndef OPCUA_EXCLUDE_Demo_WorkOrderType
&Demo_WorkOrderType_EncodeableType,
#endif
OpcUa_Null
};
OpcUa_EncodeableType** Demo_KnownEncodeableTypes1 = g_Demo_KnownEncodeableTypes1;
