open62541/include/ua_types.h

/*
 * Copyright (C) 2013-2015 the contributors as stated in the AUTHORS file
 *
 * This file is part of open62541. open62541 is free software: you can
 * redistribute it and/or modify it under the terms of the GNU Lesser General
 * Public License, version 3 (as published by the Free Software Foundation) with
 * a static linking exception as stated in the LICENSE file provided with
 * open62541.
 *
 * open62541 is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 */

#ifndef UA_TYPES_H_
#define UA_TYPES_H_

#ifdef __cplusplus
extern "C" {
#endif

#ifndef UA_FFI_BINDINGS
#include <stdbool.h>
#include <inttypes.h>
#endif

#include "ua_config.h"
#include "ua_statuscodes.h"

/* Indicates that an array has the length 0 (NULL indicates an non-defined array of length -1)*/
#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01)

/****************************/
/* Builtin Type Definitions */
/****************************/

#define UA_BUILTIN_TYPES_COUNT 25

/** A two-state logical value (true or false). */
typedef bool UA_Boolean;
#define UA_TRUE true
#define UA_FALSE false

/** An integer value between -128 and 127. */
typedef int8_t UA_SByte;
#define UA_SBYTE_MAX 127
#define UA_SBYTE_MIN -128

/** An integer value between 0 and 256. */
typedef uint8_t UA_Byte;
#define UA_BYTE_MAX 256
#define UA_BYTE_MIN 0

/** An integer value between -32 768 and 32 767. */
typedef int16_t UA_Int16;
#define UA_INT16_MAX 32767
#define UA_INT16_MIN -32768

/** An integer value between 0 and 65 535. */
typedef uint16_t UA_UInt16;
#define UA_UINT16_MAX 65535
#define UA_UINT16_MIN 0

/** An integer value between -2 147 483 648 and 2 147 483 647. */
typedef int32_t UA_Int32;
#define UA_INT32_MAX 2147483647
#define UA_INT32_MIN -2147483648

/** An integer value between 0 and 429 4967 295. */
typedef uint32_t UA_UInt32;
#define UA_UINT32_MAX 4294967295
#define UA_UINT32_MIN 0

/** An integer value between -10 223 372 036 854 775 808 and 9 223 372 036 854 775 807 */
typedef int64_t UA_Int64;
#define UA_INT64_MAX (int64_t)9223372036854775807
#define UA_INT64_MIN (int64_t)-9223372036854775808

/** An integer value between 0 and 18 446 744 073 709 551 615. */
typedef uint64_t UA_UInt64;
#define UA_UINT64_MAX (int64_t)18446744073709551615
#define UA_UINT64_MIN (int64_t)0

/** An IEEE single precision (32 bit) floating point value. */
typedef float UA_Float;

/** An IEEE double precision (64 bit) floating point value. */
typedef double UA_Double;

/** A sequence of Unicode characters. */
typedef struct {
    size_t length; ///< The length of the string
    UA_Byte *data; ///< The string's content (not null-terminated)
} UA_String;

/** An instance in time. A DateTime value is encoded as a 64-bit signed integer which represents the
    number of 100 nanosecond intervals since January 1, 1601 (UTC). */
typedef UA_Int64 UA_DateTime;

/** A 16 byte value that can be used as a globally unique identifier. */
typedef struct {
    UA_UInt32 data1;
    UA_UInt16 data2;
    UA_UInt16 data3;
    UA_Byte   data4[8];
} UA_Guid;

/** A sequence of octets. */
typedef UA_String UA_ByteString;

/** An XML element. */
typedef UA_String UA_XmlElement;

enum UA_NodeIdType {
    UA_NODEIDTYPE_NUMERIC    = 0, ///< On the wire, this can be 0,1,2 for numeric nodeids of different sizes
    UA_NODEIDTYPE_STRING     = 3,
    UA_NODEIDTYPE_GUID       = 4,
    UA_NODEIDTYPE_BYTESTRING = 5
};

/** An identifier for a node in the address space of an OPC UA Server. The shortened numeric types
    are introduced during encoding. */
typedef struct {
    UA_UInt16 namespaceIndex;
    enum UA_NodeIdType identifierType;
    union {
        UA_UInt32     numeric;
        UA_String     string;
        UA_Guid       guid;
        UA_ByteString byteString;
    } identifier;
} UA_NodeId;

/** A NodeId that allows the namespace URI to be specified instead of an index. */
typedef struct {
    UA_NodeId nodeId;
    UA_String namespaceUri;
    UA_UInt32 serverIndex;
} UA_ExpandedNodeId;

/** A name qualified by a namespace. */
typedef struct {
    UA_UInt16 namespaceIndex; ///< The namespace index
    UA_String name; ///< The actual name
} UA_QualifiedName;

/** Human readable text with an optional locale identifier. */
typedef struct {
    UA_String locale; ///< The locale (e.g. "en-US")
    UA_String text; ///< The actual text
} UA_LocalizedText;

/* Forward Declaration of UA_DataType */
struct UA_DataType;
typedef struct UA_DataType UA_DataType; 

/** A structure that contains an application specific data type that may not be recognized by the receiver. */
typedef struct {
    enum {
        UA_EXTENSIONOBJECT_ENCODED_NOBODY     = 0,
        UA_EXTENSIONOBJECT_ENCODED_BYTESTRING = 1,
        UA_EXTENSIONOBJECT_ENCODED_XML        = 2,
        UA_EXTENSIONOBJECT_DECODED            = 3, ///< There is a pointer to the decoded data
        UA_EXTENSIONOBJECT_DECODED_NODELETE   = 4  ///< Don't delete the decoded data at the lifecycle end
    } encoding;
    union {
        struct {
            UA_NodeId typeId; ///< The nodeid of the datatype
            UA_ByteString body; ///< The bytestring of the encoded data
        } encoded;
        struct {
            const UA_DataType *type;
            void *data;
        } decoded;
    } content;
} UA_ExtensionObject;

/* NumericRanges are used select a subset in a (multidimensional) variant array.
 * NumericRange has no official type structure in the standard. On the wire, it
 * only exists as an encoded string, such as "1:2,0:3,5". The colon separates
 * min/max index and the comma separates dimensions. A single value indicates a
 * range with a single element (min==max). */
typedef struct {
    size_t dimensionsSize;
    struct UA_NumericRangeDimension {
        UA_UInt32 min;
        UA_UInt32 max;
    } *dimensions;
} UA_NumericRange;

 /** Variants store (arrays of) any data type. Either they provide a pointer to the data in
 *   memory, or functions from which the data can be accessed. Variants are replaced together with
 *   the data they store (exception: use a data source).
 *
 * Variant semantics:
 *  - arrayLength == 0 && data == NULL: no existing data
 *  - arrayLength == 0 && data == 0x01: array of length 0
 *  - arrayLength == 0 && data > 0x01: scalar value
 *  - arrayLength > 0: array of the given length
 */
typedef struct {
    const UA_DataType *type; ///< The nodeid of the datatype
    enum {
        UA_VARIANT_DATA, ///< The data is "owned" by this variant (copied and deleted together)
        UA_VARIANT_DATA_NODELETE, /**< The data is "borrowed" by the variant and shall not be
                                       deleted at the end of this variant's lifecycle. It is not
                                       possible to overwrite borrowed data due to concurrent access.
                                       Use a custom datasource with a mutex. */
    } storageType; ///< Shall the data be deleted together with the variant
    size_t arrayLength;  ///< the number of elements in the data-pointer
    void *data; ///< points to the scalar or array data
    size_t arrayDimensionsSize; ///< the number of dimensions the data-array has
    UA_UInt32 *arrayDimensions; ///< the length of each dimension of the data-array
} UA_Variant;

/** A data value with an associated status code and timestamps. */
typedef struct {
    UA_Boolean    hasValue             : 1;
    UA_Boolean    hasStatus            : 1;
    UA_Boolean    hasSourceTimestamp   : 1;
    UA_Boolean    hasServerTimestamp   : 1;
    UA_Boolean    hasSourcePicoseconds : 1;
    UA_Boolean    hasServerPicoseconds : 1;
    UA_Variant    value;
    UA_StatusCode status;
    UA_DateTime   sourceTimestamp;
    UA_Int16      sourcePicoseconds;
    UA_DateTime   serverTimestamp;
    UA_Int16      serverPicoseconds;
} UA_DataValue;

/** A structure that contains detailed error and diagnostic information associated with a StatusCode. */
typedef struct UA_DiagnosticInfo {
    UA_Boolean    hasSymbolicId          : 1;
    UA_Boolean    hasNamespaceUri        : 1;
    UA_Boolean    hasLocalizedText       : 1;
    UA_Boolean    hasLocale              : 1;
    UA_Boolean    hasAdditionalInfo      : 1;
    UA_Boolean    hasInnerStatusCode     : 1;
    UA_Boolean    hasInnerDiagnosticInfo : 1;
    UA_Int32      symbolicId;
    UA_Int32      namespaceUri;
    UA_Int32      localizedText;
    UA_Int32      locale;
    UA_String     additionalInfo;
    UA_StatusCode innerStatusCode;
    struct UA_DiagnosticInfo *innerDiagnosticInfo;
} UA_DiagnosticInfo;

/*************************/
/* Generic Type Handling */
/*************************/

#define UA_MAX_TYPE_MEMBERS 13 // Maximum number of members per structured type

typedef struct {
#ifdef ENABLE_TYPEINTROSPECTION
    const char *memberName;
#endif
    UA_UInt16   memberTypeIndex;   ///< Index of the member in the datatypetable
    UA_Byte     padding;           /**< How much padding is there before this member element? For arrays this is
                                        split into 2 bytes padding before the length index (max 4 bytes) and 3
                                        bytes padding before the pointer (max 8 bytes) */
    UA_Boolean  namespaceZero : 1; /**< The type of the member is defined in namespace zero. In this
                                        implementation, types from custom namespace may contain
                                        members from the same namespace or ns0 only.*/
    UA_Boolean  isArray       : 1; ///< The member is an array of the given type
} UA_DataTypeMember;
    
struct UA_DataType {
#ifdef ENABLE_TYPEINTROSPECTION
    const char *typeName;
#endif
    UA_NodeId   typeId;           ///< The nodeid of the type
    UA_UInt16   memSize;          ///< Size of the struct in memory
    UA_UInt16   typeIndex;        ///< Index of the type in the datatypetable
    UA_Byte     membersSize;      ///< How many members does the type have?
    UA_Boolean  builtin      : 1; ///< The type is "builtin" and has dedicated de- and encoding functions
    UA_Boolean  fixedSize    : 1; ///< The type (and its members) contains no pointers
    UA_Boolean  zeroCopyable : 1; ///< The type can be copied directly off the stream (given that the endianness matches)
    UA_DataTypeMember members[UA_MAX_TYPE_MEMBERS];
};

/**
 * Allocates and initializes a variable of type dataType
 *
 * @param type The datatype description
 * @return Returns the memory location of the variable or (void*)0 if no memory is available
 */
void UA_EXPORT * UA_new(const UA_DataType *type) UA_FUNC_ATTR_MALLOC;

/**
 * Initializes a variable to default values
 *
 * @param p The memory location of the variable
 * @param type The datatype description
 */
void UA_EXPORT UA_init(void *p, const UA_DataType *type);

/**
 * Copies the content of two variables. If copying fails (e.g. because no memory was available for
 * an array), then dst is emptied and initialized to prevent memory leaks.
 *
 * @param src The memory location of the source variable
 * @param dst The memory location of the destination variable
 * @param type The datatype description
 * @return Indicates whether the operation succeeded or returns an error code
 */
UA_StatusCode UA_EXPORT
UA_copy(const void *src, void *dst, const UA_DataType *type) UA_FUNC_ATTR_WARN_UNUSED_RESULT;

/**
 * Deletes the dynamically assigned content of a variable (e.g. a member-array).
 * Afterwards, the variable can be safely deleted without causing memory leaks.
 * But the variable is not initialized and may contain old data that is not
 * memory-relevant.
 *
 * @param p The memory location of the variable
 * @param type The datatype description of the variable
 */
void UA_EXPORT UA_deleteMembers(void *p, const UA_DataType *type);

/**
 * Deletes (frees) a variable and all of its content.
 *
 * @param p The memory location of the variable
 * @param type The datatype description of the variable
 */
void UA_EXPORT UA_delete(void *p, const UA_DataType *type);

/********************/
/* Array operations */
/********************/

#define MAX_ARRAY_SIZE 104857600 // arrays must be smaller than 100MB

/**
 * Allocates and initializes an array of variables of a specific type
 *
 * @param size The requested array length
 * @param type The datatype description
 * @return Returns the memory location of the variable or (void*)0 if no memory could be allocated
 */
void UA_EXPORT * UA_Array_new(size_t size, const UA_DataType *type) UA_FUNC_ATTR_MALLOC;

/**
 * Allocates and copies an array. dst is set to (void*)0 if not enough memory is available.
 *
 * @param src The memory location of the source array
 * @param src_size The size of the array
 * @param dst The location of the pointer to the new array
 * @param type The datatype of the array members
 * @return Returns whether copying succeeded
 */
UA_StatusCode UA_EXPORT
UA_Array_copy(const void *src, size_t src_size, void **dst,
              const UA_DataType *type) UA_FUNC_ATTR_WARN_UNUSED_RESULT;

/**
 * Deletes an array.
 *
 * @param p The memory location of the array
 * @param size The size of the array
 * @param type The datatype of the array members
 */
void UA_EXPORT UA_Array_delete(void *p, size_t size, const UA_DataType *type);

/***********************************/
/* Builtin Type Handling Functions */
/***********************************/

#include "ua_types_generated.h"

/* Boolean */
static UA_INLINE UA_Boolean * UA_Boolean_new(void) { return UA_new(&UA_TYPES[UA_TYPES_BOOLEAN]); }
static UA_INLINE void UA_Boolean_init(UA_Boolean *p) { *p = UA_FALSE; }
static UA_INLINE void UA_Boolean_delete(UA_Boolean *p) { UA_delete(p, &UA_TYPES[UA_TYPES_BOOLEAN]); }
static UA_INLINE void UA_Boolean_deleteMembers(UA_Boolean *p) { }
static UA_INLINE UA_StatusCode UA_Boolean_copy(const UA_Boolean *src, UA_Boolean *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* SByte */
static UA_INLINE UA_SByte * UA_SByte_new(void) { return UA_new(&UA_TYPES[UA_TYPES_SBYTE]); }
static UA_INLINE void UA_SByte_init(UA_SByte *p) { *p = 0; }
static UA_INLINE void UA_SByte_delete(UA_SByte *p) { UA_delete(p, &UA_TYPES[UA_TYPES_SBYTE]); }
static UA_INLINE void UA_SByte_deleteMembers(UA_SByte *p) { }
static UA_INLINE UA_StatusCode UA_SByte_copy(const UA_SByte *src, UA_SByte *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* Byte */
static UA_INLINE UA_Byte * UA_Byte_new(void) { return UA_new(&UA_TYPES[UA_TYPES_BYTE]); }
static UA_INLINE void UA_Byte_init(UA_Byte *p) { *p = 0; }
static UA_INLINE void UA_Byte_delete(UA_Byte *p) { UA_delete(p, &UA_TYPES[UA_TYPES_BYTE]); }
static UA_INLINE void UA_Byte_deleteMembers(UA_Byte *p) { }
static UA_INLINE UA_StatusCode UA_Byte_copy(const UA_Byte *src, UA_Byte *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* Int16 */
static UA_INLINE UA_Int16 * UA_Int16_new(void) { return UA_new(&UA_TYPES[UA_TYPES_INT16]); }
static UA_INLINE void UA_Int16_init(UA_Int16 *p) { *p = 0; }
static UA_INLINE void UA_Int16_delete(UA_Int16 *p) { UA_delete(p, &UA_TYPES[UA_TYPES_INT16]); }
static UA_INLINE void UA_Int16_deleteMembers(UA_Int16 *p) { }
static UA_INLINE UA_StatusCode UA_Int16_copy(const UA_Int16 *src, UA_Int16 *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* UInt16 */
static UA_INLINE UA_UInt16 * UA_UInt16_new(void) { return UA_new(&UA_TYPES[UA_TYPES_UINT16]); }
static UA_INLINE void UA_UInt16_init(UA_UInt16 *p) { *p = 0; }
static UA_INLINE void UA_UInt16_delete(UA_UInt16 *p) { UA_delete(p, &UA_TYPES[UA_TYPES_UINT16]); }
static UA_INLINE void UA_UInt16_deleteMembers(UA_UInt16 *p) { }
static UA_INLINE UA_StatusCode UA_UInt16_copy(const UA_UInt16 *src, UA_UInt16 *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* Int32 */
static UA_INLINE UA_Int32 * UA_Int32_new(void) { return UA_new(&UA_TYPES[UA_TYPES_INT32]); }
static UA_INLINE void UA_Int32_init(UA_Int32 *p) { *p = 0; }
static UA_INLINE void UA_Int32_delete(UA_Int32 *p) { UA_delete(p, &UA_TYPES[UA_TYPES_INT32]); }
static UA_INLINE void UA_Int32_deleteMembers(UA_Int32 *p) { }
static UA_INLINE UA_StatusCode UA_Int32_copy(const UA_Int32 *src, UA_Int32 *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* UInt32 */
static UA_INLINE UA_UInt32 * UA_UInt32_new(void) { return UA_new(&UA_TYPES[UA_TYPES_UINT32]); }
static UA_INLINE void UA_UInt32_init(UA_UInt32 *p) { *p = 0; }
static UA_INLINE void UA_UInt32_delete(UA_UInt32 *p) { UA_delete(p, &UA_TYPES[UA_TYPES_UINT32]); }
static UA_INLINE void UA_UInt32_deleteMembers(UA_UInt32 *p) { }
static UA_INLINE UA_StatusCode UA_UInt32_copy(const UA_UInt32 *src, UA_UInt32 *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* Int64 */
static UA_INLINE UA_Int64 * UA_Int64_new(void) { return UA_new(&UA_TYPES[UA_TYPES_INT64]); }
static UA_INLINE void UA_Int64_init(UA_Int64 *p) { *p = 0; }
static UA_INLINE void UA_Int64_delete(UA_Int64 *p) { UA_delete(p, &UA_TYPES[UA_TYPES_INT64]); }
static UA_INLINE void UA_Int64_deleteMembers(UA_Int64 *p) { }
static UA_INLINE UA_StatusCode UA_Int64_copy(const UA_Int64 *src, UA_Int64 *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* UInt64 */
static UA_INLINE UA_UInt64 * UA_UInt64_new(void) { return UA_new(&UA_TYPES[UA_TYPES_UINT64]); }
static UA_INLINE void UA_UInt64_init(UA_UInt64 *p) { *p = 0; }
static UA_INLINE void UA_UInt64_delete(UA_UInt64 *p) { UA_delete(p, &UA_TYPES[UA_TYPES_UINT64]); }
static UA_INLINE void UA_UInt64_deleteMembers(UA_UInt64 *p) { }
static UA_INLINE UA_StatusCode UA_UInt64_copy(const UA_UInt64 *src, UA_UInt64 *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* Float */
static UA_INLINE UA_Float * UA_Float_new(void) { return UA_new(&UA_TYPES[UA_TYPES_FLOAT]); }
static UA_INLINE void UA_Float_init(UA_Float *p) { *p = 0.0f; }
static UA_INLINE void UA_Float_delete(UA_Float *p) { UA_delete(p, &UA_TYPES[UA_TYPES_FLOAT]); }
static UA_INLINE void UA_Float_deleteMembers(UA_Float *p) { }
static UA_INLINE UA_StatusCode UA_Float_copy(const UA_Float *src, UA_Float *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* Double */
static UA_INLINE UA_Double * UA_Double_new(void) { return UA_new(&UA_TYPES[UA_TYPES_DOUBLE]); }
static UA_INLINE void UA_Double_init(UA_Double *p) { *p = 0.0f; }
static UA_INLINE void UA_Double_delete(UA_Double *p) { UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLE]); }
static UA_INLINE void UA_Double_deleteMembers(UA_Double *p) { }
static UA_INLINE UA_StatusCode UA_Double_copy(const UA_Double *src, UA_Double *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

/* String */
static UA_INLINE UA_String * UA_String_new(void) { return UA_new(&UA_TYPES[UA_TYPES_STRING]); }
static UA_INLINE void UA_String_init(UA_String *p) { memset(p, 0, sizeof(UA_String)); }
static UA_INLINE void UA_String_delete(UA_String *p) { UA_delete(p, &UA_TYPES[UA_TYPES_STRING]); }
static UA_INLINE void UA_String_deleteMembers(UA_String *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_STRING]); }
static UA_INLINE UA_StatusCode UA_String_copy(const UA_String *src, UA_String *dst) {return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRING]); }

/** Copies the content on the heap. Returns a null-string when alloc fails */
UA_String UA_EXPORT UA_String_fromChars(char const src[]);

UA_Boolean UA_EXPORT UA_String_equal(const UA_String *s1, const UA_String *s2);

UA_EXPORT extern const UA_String UA_STRING_NULL;

static UA_INLINE UA_String UA_STRING(char *chars) {
    UA_String str;
    str.length = strlen(chars);
    str.data   = (UA_Byte*)chars;
    return str; }

#define UA_STRING_ALLOC(CHARS) UA_String_fromChars(CHARS)

/* DateTime */
static UA_INLINE UA_DateTime * UA_DateTime_new(void) { return UA_new(&UA_TYPES[UA_TYPES_DATETIME]); }
static UA_INLINE void UA_DateTime_init(UA_DateTime *p) { *p = 0; }
static UA_INLINE void UA_DateTime_delete(UA_DateTime *p) { UA_delete(p, &UA_TYPES[UA_TYPES_DATETIME]); }
static UA_INLINE void UA_DateTime_deleteMembers(UA_DateTime *p) { }
static UA_INLINE UA_StatusCode UA_DateTime_copy(const UA_DateTime *src, UA_DateTime *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

UA_DateTime UA_EXPORT UA_DateTime_now(void); ///> The current time

typedef struct UA_DateTimeStruct {
    UA_UInt16 nanoSec;
    UA_UInt16 microSec;
    UA_UInt16 milliSec;
    UA_UInt16 sec;
    UA_UInt16 min;
    UA_UInt16 hour;
    UA_UInt16 day;
    UA_UInt16 month;
    UA_UInt16 year;
} UA_DateTimeStruct;

UA_DateTimeStruct UA_EXPORT UA_DateTime_toStruct(UA_DateTime time);

UA_String UA_EXPORT UA_DateTime_toString(UA_DateTime time);

/* Guid */
static UA_INLINE UA_Guid * UA_Guid_new(void) { return UA_new(&UA_TYPES[UA_TYPES_GUID]); }
static UA_INLINE void UA_Guid_init(UA_Guid *p) { memset(p, 0, sizeof(UA_Guid)); }
static UA_INLINE void UA_Guid_delete(UA_Guid *p) { UA_delete(p, &UA_TYPES[UA_TYPES_GUID]); }
static UA_INLINE void UA_Guid_deleteMembers(UA_Guid *p) { }
static UA_INLINE UA_StatusCode UA_Guid_copy(const UA_Guid *src, UA_Guid *dst) { *dst = *src; return UA_STATUSCODE_GOOD; }

UA_Boolean UA_EXPORT UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2);

UA_Guid UA_EXPORT UA_Guid_random(UA_UInt32 *seed);

/* ByteString */
static UA_INLINE UA_ByteString * UA_ByteString_new(void) { return UA_new(&UA_TYPES[UA_TYPES_BYTESTRING]); }
static UA_INLINE void UA_ByteString_init(UA_ByteString *p) { memset(p, 0, sizeof(UA_ByteString)); }
static UA_INLINE void UA_ByteString_delete(UA_ByteString *p) { UA_delete(p, &UA_TYPES[UA_TYPES_BYTESTRING]); }
static UA_INLINE void UA_ByteString_deleteMembers(UA_ByteString *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_BYTESTRING]); }
static UA_INLINE UA_StatusCode UA_ByteString_copy(const UA_ByteString *src, UA_ByteString *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTESTRING]); }

static UA_INLINE UA_Boolean UA_ByteString_equal(const UA_ByteString *string1, const UA_ByteString *string2) {
    return UA_String_equal((const UA_String*)string1, (const UA_String*)string2); }

/* Allocates memory of size length for the bytestring. The content is not set to zero. */
UA_ByteString UA_EXPORT UA_ByteString_withSize(size_t length);

UA_EXPORT extern const UA_ByteString UA_BYTESTRING_NULL;

static UA_INLINE UA_ByteString UA_BYTESTRING(char *chars) {
    UA_ByteString str;
    str.length = strlen(chars);
    str.data   = (UA_Byte*)chars;
    return str; }

static UA_INLINE UA_ByteString UA_BYTESTRING_ALLOC(const char *chars) {
    UA_String str = UA_String_fromChars(chars);
    UA_ByteString bstr;
    bstr.length = str.length;
    bstr.data   = str.data;
    return bstr;
}

/* XmlElement */
static UA_INLINE UA_XmlElement * UA_XmlElement_new(void) { return UA_new(&UA_TYPES[UA_TYPES_XMLELEMENT]); }
static UA_INLINE void UA_XmlElement_init(UA_XmlElement *p) { memset(p, 0, sizeof(UA_XmlElement)); }
static UA_INLINE void UA_XmlElement_delete(UA_XmlElement *p) { UA_delete(p, &UA_TYPES[UA_TYPES_XMLELEMENT]); }
static UA_INLINE void UA_XmlElement_deleteMembers(UA_XmlElement *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_XMLELEMENT]); }
static UA_INLINE UA_StatusCode UA_XmlElement_copy(const UA_XmlElement *src, UA_XmlElement *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XMLELEMENT]); }

/* NodeId */
static UA_INLINE UA_NodeId * UA_NodeId_new(void) { return UA_new(&UA_TYPES[UA_TYPES_NODEID]); }
static UA_INLINE void UA_NodeId_init(UA_NodeId *p) { memset(p, 0, sizeof(UA_NodeId)); }
static UA_INLINE void UA_NodeId_delete(UA_NodeId *p) { UA_delete(p, &UA_TYPES[UA_TYPES_NODEID]); }
static UA_INLINE void UA_NodeId_deleteMembers(UA_NodeId *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_NODEID]); }
static UA_INLINE UA_StatusCode UA_NodeId_copy(const UA_NodeId *src, UA_NodeId *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEID]); }

UA_Boolean UA_EXPORT UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2);

static UA_INLINE UA_Boolean UA_NodeId_isNull(const UA_NodeId *p) {
    return (p->namespaceIndex == 0 && p->identifierType == UA_NODEIDTYPE_NUMERIC &&
            p->identifier.numeric == 0);
}

UA_EXPORT extern const UA_NodeId UA_NODEID_NULL;

static UA_INLINE UA_NodeId UA_NODEID_NUMERIC(UA_UInt16 nsIndex, UA_Int32 identifier) {
    UA_NodeId id;
    id.namespaceIndex = nsIndex;
    id.identifierType = UA_NODEIDTYPE_NUMERIC;
    id.identifier.numeric = identifier;
    return id; }

static UA_INLINE UA_NodeId UA_NODEID_STRING(UA_UInt16 nsIndex, char *chars) {
    UA_NodeId id;
    id.namespaceIndex = nsIndex;
    id.identifierType = UA_NODEIDTYPE_STRING;
    id.identifier.string = UA_STRING(chars);
    return id; }

static UA_INLINE UA_NodeId UA_NODEID_STRING_ALLOC(UA_UInt16 nsIndex, const char *chars) {
    UA_NodeId id;
    id.namespaceIndex = nsIndex;
    id.identifierType = UA_NODEIDTYPE_STRING;
    id.identifier.string = UA_STRING_ALLOC(chars);
    return id; }

static UA_INLINE UA_NodeId UA_NODEID_GUID(UA_UInt16 nsIndex, UA_Guid guid) {
    UA_NodeId id;
    id.namespaceIndex = nsIndex;
    id.identifierType = UA_NODEIDTYPE_GUID;
    id.identifier.guid = guid;
    return id; }

static UA_INLINE UA_NodeId UA_NODEID_BYTESTRING(UA_UInt16 nsIndex, char *chars) {
    UA_NodeId id;
    id.namespaceIndex = nsIndex;
    id.identifierType = UA_NODEIDTYPE_BYTESTRING;
    id.identifier.byteString = UA_BYTESTRING(chars);
    return id; }

static UA_INLINE UA_NodeId UA_NODEID_BYTESTRING_ALLOC(UA_UInt16 nsIndex, const char *chars) {
    UA_NodeId id;
    id.namespaceIndex = nsIndex;
    id.identifierType = UA_NODEIDTYPE_BYTESTRING;
    id.identifier.byteString = UA_BYTESTRING_ALLOC(chars);
    return id; }

/* ExpandedNodeId */
static UA_INLINE UA_ExpandedNodeId * UA_ExpandedNodeId_new(void) { return UA_new(&UA_TYPES[UA_TYPES_EXPANDEDNODEID]); }
static UA_INLINE void UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) { memset(p, 0, sizeof(UA_ExpandedNodeId)); }
static UA_INLINE void UA_ExpandedNodeId_delete(UA_ExpandedNodeId *p) { UA_delete(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); }
static UA_INLINE void UA_ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); }
static UA_INLINE UA_StatusCode UA_ExpandedNodeId_copy(const UA_ExpandedNodeId *src, UA_ExpandedNodeId *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); }

static UA_INLINE UA_ExpandedNodeId UA_EXPANDEDNODEID_NUMERIC(UA_UInt16 nsIndex, UA_Int32 identifier) {
    UA_ExpandedNodeId id;
    id.nodeId       = UA_NODEID_NUMERIC(nsIndex, identifier);
    id.serverIndex  = 0;
    id.namespaceUri = UA_STRING_NULL;
    return id; }

static UA_INLINE UA_ExpandedNodeId UA_EXPANDEDNODEID_STRING(UA_UInt16 nsIndex, char *chars) {
    UA_ExpandedNodeId id;
    id.nodeId       = UA_NODEID_STRING(nsIndex, chars);
    id.serverIndex  = 0;
    id.namespaceUri = UA_STRING_NULL;
    return id; }

static UA_INLINE UA_ExpandedNodeId UA_EXPANDEDNODEID_STRING_ALLOC(UA_UInt16 nsIndex, const char *chars) {
    UA_ExpandedNodeId id;
    id.nodeId       = UA_NODEID_STRING_ALLOC(nsIndex, chars);
    id.serverIndex  = 0;
    id.namespaceUri = UA_STRING_NULL;
    return id; }

static UA_INLINE UA_ExpandedNodeId UA_EXPANDEDNODEID_STRING_GUID(UA_UInt16 nsIndex, UA_Guid guid) {
    UA_ExpandedNodeId id;
    id.nodeId       = UA_NODEID_GUID(nsIndex, guid);
    id.serverIndex  = 0;
    id.namespaceUri = UA_STRING_NULL;
    return id; }

static UA_INLINE UA_ExpandedNodeId UA_EXPANDEDNODEID_BYTESTRING(UA_UInt16 nsIndex, char *chars) {
    UA_ExpandedNodeId id;
    id.nodeId       = UA_NODEID_BYTESTRING(nsIndex, chars);
    id.serverIndex  = 0;
    id.namespaceUri = UA_STRING_NULL;
    return id; }

static UA_INLINE UA_ExpandedNodeId UA_EXPANDEDNODEID_BYTESTRING_ALLOC(UA_UInt16 nsIndex, const char *chars) {
    UA_ExpandedNodeId id;
    id.nodeId       = UA_NODEID_BYTESTRING_ALLOC(nsIndex, chars);
    id.serverIndex  = 0;
    id.namespaceUri = UA_STRING_NULL;
    return id; }

/* StatusCode */
static UA_INLINE UA_StatusCode * UA_StatusCode_new(void) { return UA_new(&UA_TYPES[UA_TYPES_STATUSCODE]); }
static UA_INLINE void UA_StatusCode_init(UA_StatusCode *p) { *p = UA_STATUSCODE_GOOD; }
static UA_INLINE void UA_StatusCode_delete(UA_StatusCode *p) { UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCODE]); }
static UA_INLINE void UA_StatusCode_deleteMembers(UA_StatusCode *p) { }
static UA_INLINE UA_StatusCode UA_StatusCode_copy(const UA_StatusCode *src, UA_StatusCode *dst) {*dst = *src; return UA_STATUSCODE_GOOD; }

/* QualifiedName */
static UA_INLINE UA_QualifiedName * UA_QualifiedName_new(void) { return UA_new(&UA_TYPES[UA_TYPES_QUALIFIEDNAME]); }
static UA_INLINE void UA_QualifiedName_init(UA_QualifiedName *p) { memset(p, 0, sizeof(UA_QualifiedName)); }
static UA_INLINE void UA_QualifiedName_delete(UA_QualifiedName *p) { UA_delete(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); }
static UA_INLINE void UA_QualifiedName_deleteMembers(UA_QualifiedName *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); }
static UA_INLINE UA_StatusCode UA_QualifiedName_copy(const UA_QualifiedName *src, UA_QualifiedName *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); }

static UA_INLINE UA_QualifiedName UA_QUALIFIEDNAME(UA_UInt16 nsIndex, char *chars) {
    UA_QualifiedName qn;
    qn.namespaceIndex = nsIndex;
    qn.name           = UA_STRING(chars);
    return qn; }

static UA_INLINE UA_QualifiedName UA_QUALIFIEDNAME_ALLOC(UA_UInt16 nsIndex, const char *chars) {
    UA_QualifiedName qn;
    qn.namespaceIndex = nsIndex;
    qn.name           = UA_STRING_ALLOC(chars);
    return qn; }

/* LocalizedText */
static UA_INLINE UA_LocalizedText * UA_LocalizedText_new(void) { return UA_new(&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); }
static UA_INLINE void UA_LocalizedText_init(UA_LocalizedText *p) { memset(p, 0, sizeof(UA_LocalizedText)); }
static UA_INLINE void UA_LocalizedText_delete(UA_LocalizedText *p) { UA_delete(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); }
static UA_INLINE void UA_LocalizedText_deleteMembers(UA_LocalizedText *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); }
static UA_INLINE UA_StatusCode UA_LocalizedText_copy(const UA_LocalizedText *src, UA_LocalizedText *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); }

static UA_INLINE UA_LocalizedText UA_LOCALIZEDTEXT(char *locale, char *text) {
    UA_LocalizedText lt;
    lt.locale = UA_STRING(locale);
    lt.text   = UA_STRING(text);
    return lt; }

static UA_INLINE UA_LocalizedText UA_LOCALIZEDTEXT_ALLOC(const char *locale, const char *text) {
    UA_LocalizedText lt;
    lt.locale = UA_STRING_ALLOC(locale);
    lt.text   = UA_STRING_ALLOC(text);
    return lt; }

/* ExtensionObject */
static UA_INLINE UA_ExtensionObject * UA_ExtensionObject_new(void) { return UA_new(&UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); }
static UA_INLINE void UA_ExtensionObject_init(UA_ExtensionObject *p) { memset(p, 0, sizeof(UA_ExtensionObject)); }
static UA_INLINE void UA_ExtensionObject_delete(UA_ExtensionObject *p) { UA_delete(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); }
static UA_INLINE void UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); }
static UA_INLINE UA_StatusCode UA_ExtensionObject_copy(const UA_ExtensionObject *src, UA_ExtensionObject *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); }

/* Variant */
static UA_INLINE UA_Variant * UA_Variant_new(void) { return UA_new(&UA_TYPES[UA_TYPES_VARIANT]); }
static UA_INLINE void UA_Variant_init(UA_Variant *p) { memset(p, 0, sizeof(UA_Variant)); }
static UA_INLINE void UA_Variant_delete(UA_Variant *p) { UA_delete(p, &UA_TYPES[UA_TYPES_VARIANT]); }
static UA_INLINE void UA_Variant_deleteMembers(UA_Variant *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_VARIANT]); }
static UA_INLINE UA_StatusCode UA_Variant_copy(const UA_Variant *src, UA_Variant *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIANT]); }

/**
 * Returns true if the variant contains a scalar value. Note that empty variants contain an array of
 * length -1 (undefined).
 *
 * @param v The variant
 * @return Does the variant contain a scalar value.
 */
static UA_INLINE UA_Boolean UA_Variant_isScalar(const UA_Variant *v) {
    return (v->arrayLength == 0 && v->data >= UA_EMPTY_ARRAY_SENTINEL); }
    
/**
 * Set the variant to a scalar value that already resides in memory. The value takes on the
 * lifecycle of the variant and is deleted with it.
 *
 * @param v The variant
 * @param p A pointer to the value data
 * @param type The datatype of the value in question
 * @return Indicates whether the operation succeeded or returns an error code
 */
UA_StatusCode UA_EXPORT UA_Variant_setScalar(UA_Variant *v, void * UA_RESTRICT p, const UA_DataType *type);

/**
 * Set the variant to a scalar value that is copied from an existing variable.
 *
 * @param v The variant
 * @param p A pointer to the value data
 * @param type The datatype of the value
 * @return Indicates whether the operation succeeded or returns an error code
 */
UA_StatusCode UA_EXPORT UA_Variant_setScalarCopy(UA_Variant *v, const void *p, const UA_DataType *type);

/**
 * Set the variant to an array that already resides in memory. The array takes on the lifecycle of
 * the variant and is deleted with it.
 *
 * @param v The variant
 * @param array A pointer to the array data
 * @param arraySize The size of the array
 * @param type The datatype of the array
 * @return Indicates whether the operation succeeded or returns an error code
 */
UA_StatusCode UA_EXPORT
UA_Variant_setArray(UA_Variant *v, void * UA_RESTRICT array, size_t arraySize, const UA_DataType *type);

/**
 * Set the variant to an array that is copied from an existing array.
 *
 * @param v The variant
 * @param array A pointer to the array data
 * @param arraySize The size of the array
 * @param type The datatype of the array
 * @return Indicates whether the operation succeeded or returns an error code
 */
UA_StatusCode UA_EXPORT
UA_Variant_setArrayCopy(UA_Variant *v, const void *array, size_t arraySize, const UA_DataType *type);

/**
 * Copy the variant, but use only a subset of the (multidimensional) array into a variant. Returns
 * an error code if the variant is not an array or if the indicated range does not fit.
 *
 * @param src The source variant
 * @param dst The target variant
 * @param range The range of the copied data
 * @return Returns UA_STATUSCODE_GOOD or an error code
 */
UA_StatusCode UA_EXPORT
UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, const UA_NumericRange range);

/**
 * Insert a range of data into an existing variant. The data array can't be reused afterwards if it
 * contains types without a fixed size (e.g. strings) since the members are moved into the variant
 * and take on its lifecycle.
 *
 * @param v The variant
 * @param dataArray The data array. The type must match the variant
 * @param dataArraySize The length of the data array. This is checked to match the range size.
 * @param range The range of where the new data is inserted
 * @return Returns UA_STATUSCODE_GOOD or an error code
 */
UA_StatusCode UA_EXPORT
UA_Variant_setRange(UA_Variant *v, void * UA_RESTRICT array, size_t arraySize, const UA_NumericRange range);

/**
 * Deep-copy a range of data into an existing variant.
 *
 * @param v The variant
 * @param dataArray The data array. The type must match the variant
 * @param dataArraySize The length of the data array. This is checked to match the range size.
 * @param range The range of where the new data is inserted
 * @return Returns UA_STATUSCODE_GOOD or an error code
 */
UA_StatusCode UA_EXPORT
UA_Variant_setRangeCopy(UA_Variant *v, const void *array, size_t arraySize, const UA_NumericRange range);

/* DataValue */
static UA_INLINE UA_DataValue * UA_DataValue_new(void) { return UA_new(&UA_TYPES[UA_TYPES_DATAVALUE]); }
static UA_INLINE void UA_DataValue_init(UA_DataValue *p) { memset(p, 0, sizeof(UA_DataValue)); }
static UA_INLINE void UA_DataValue_delete(UA_DataValue *p) { UA_delete(p, &UA_TYPES[UA_TYPES_DATAVALUE]); }
static UA_INLINE void UA_DataValue_deleteMembers(UA_DataValue *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_DATAVALUE]); }
static UA_INLINE UA_StatusCode UA_DataValue_copy(const UA_DataValue *src, UA_DataValue *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAVALUE]); }

/* DiagnosticInfo */
static UA_INLINE UA_DiagnosticInfo * UA_DiagnosticInfo_new(void) { return UA_new(&UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); }
static UA_INLINE void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) { memset(p, 0, sizeof(UA_DiagnosticInfo)); }
static UA_INLINE void UA_DiagnosticInfo_delete(UA_DiagnosticInfo *p) { UA_delete(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); }
static UA_INLINE void UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) { UA_deleteMembers(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); }
static UA_INLINE UA_StatusCode UA_DiagnosticInfo_copy(const UA_DiagnosticInfo *src, UA_DiagnosticInfo *dst) { return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); }

/**********************/
/* Node Attribute Ids */
/**********************/

/* These are not generated from XML. Server *and* client need them. */
typedef enum {
    UA_ATTRIBUTEID_NODEID                  = 1,
    UA_ATTRIBUTEID_NODECLASS               = 2,
    UA_ATTRIBUTEID_BROWSENAME              = 3,
    UA_ATTRIBUTEID_DISPLAYNAME             = 4,
    UA_ATTRIBUTEID_DESCRIPTION             = 5,
    UA_ATTRIBUTEID_WRITEMASK               = 6,
    UA_ATTRIBUTEID_USERWRITEMASK           = 7,
    UA_ATTRIBUTEID_ISABSTRACT              = 8,
    UA_ATTRIBUTEID_SYMMETRIC               = 9,
    UA_ATTRIBUTEID_INVERSENAME             = 10,
    UA_ATTRIBUTEID_CONTAINSNOLOOPS         = 11,
    UA_ATTRIBUTEID_EVENTNOTIFIER           = 12,
    UA_ATTRIBUTEID_VALUE                   = 13,
    UA_ATTRIBUTEID_DATATYPE                = 14,
    UA_ATTRIBUTEID_VALUERANK               = 15,
    UA_ATTRIBUTEID_ARRAYDIMENSIONS         = 16,
    UA_ATTRIBUTEID_ACCESSLEVEL             = 17,
    UA_ATTRIBUTEID_USERACCESSLEVEL         = 18,
    UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL = 19,
    UA_ATTRIBUTEID_HISTORIZING             = 20,
    UA_ATTRIBUTEID_EXECUTABLE              = 21,
    UA_ATTRIBUTEID_USEREXECUTABLE          = 22
} UA_AttributeId;

/***************************/
/* Random Number Generator */
/***************************/

/**
 * If UA_MULTITHREADING is enabled, then the seed is stored in thread local storage. The seed is
 * initialized for every thread in the server/client.
 */
UA_EXPORT void UA_random_seed(UA_UInt64 seed);
UA_EXPORT UA_UInt32 UA_random(void);

#ifdef __cplusplus
} // extern "C"
#endif

#endif /* UA_TYPES_H_ */