ua_types.h 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594
  1. /*
  2. * Copyright (C) 2014 the contributors as stated in the AUTHORS file
  3. *
  4. * This file is part of open62541. open62541 is free software: you can
  5. * redistribute it and/or modify it under the terms of the GNU Lesser General
  6. * Public License, version 3 (as published by the Free Software Foundation) with
  7. * a static linking exception as stated in the LICENSE file provided with
  8. * open62541.
  9. *
  10. * open62541 is distributed in the hope that it will be useful, but WITHOUT ANY
  11. * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12. * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  13. * details.
  14. */
  15. #ifndef UA_TYPES_H_
  16. #define UA_TYPES_H_
  17. #ifdef __cplusplus
  18. extern "C" {
  19. #endif
  20. #include <stdint.h>
  21. #include <stdbool.h>
  22. #include <stddef.h>
  23. #include "ua_config.h"
  24. /**
  25. * @defgroup types Datatypes
  26. *
  27. * @brief The built-in datatypes. The remaining datatypes are autogenerated from
  28. * XML descriptions as they are all enums or structures made up of the built-in
  29. * datatypes.
  30. *
  31. * All datatypes have similar functions with a common postfix. DO NOT CALL THESE
  32. * FUNCTIONS WITH NULL-POINTERS IF IT IS NOT EXPLICITLY PERMITTED.
  33. *
  34. * - _new: Allocates the memory for the type and runs _init on the returned
  35. * variable. Returns null if no memory could be allocated.
  36. *
  37. * - _init: Sets all members to a "safe" standard, usually zero. Arrays (e.g.
  38. * for strings) are set to a length of -1.
  39. *
  40. * - _copy: Copies a datatype. This performs a deep copy that iterates over the
  41. * members. Copying into variants with an external data source is not
  42. * permitted. If copying fails, a deleteMembers is performed and an error
  43. * code returned.
  44. *
  45. * - _delete: Frees the memory where the datatype was stored. This performs an
  46. * _deleteMembers internally if required.
  47. *
  48. * - _deleteMembers: Frees the memory of dynamically sized members (e.g. a
  49. * string) of a datatype. This is useful when the datatype was allocated on
  50. * the stack, whereas the dynamically sized members is heap-allocated. To
  51. * reuse the variable, the remaining members (not dynamically allocated) need
  52. * to be cleaned up with an _init.
  53. *
  54. * @{
  55. */
  56. /** @brief A two-state logical value (true or false). */
  57. typedef bool UA_Boolean;
  58. #define UA_TRUE true
  59. #define UA_FALSE false
  60. /** @brief An integer value between -129 and 127. */
  61. typedef int8_t UA_SByte;
  62. #define UA_SBYTE_MAX 127
  63. #define UA_SBYTE_MIN -128
  64. /** @brief An integer value between 0 and 256. */
  65. typedef uint8_t UA_Byte;
  66. #define UA_BYTE_MAX 256
  67. #define UA_BYTE_MIN 0
  68. /** @brief An integer value between -32 768 and 32 767. */
  69. typedef int16_t UA_Int16;
  70. #define UA_INT16_MAX 32767
  71. #define UA_INT16_MIN -32768
  72. /** @brief An integer value between 0 and 65 535. */
  73. typedef uint16_t UA_UInt16;
  74. #define UA_UINT16_MAX 65535
  75. #define UA_UINT16_MIN 0
  76. /** @brief An integer value between -2 147 483 648 and 2 147 483 647. */
  77. typedef int32_t UA_Int32;
  78. #define UA_INT32_MAX 2147483647
  79. #define UA_INT32_MIN -2147483648
  80. /** @brief An integer value between 0 and 429 4967 295. */
  81. typedef uint32_t UA_UInt32;
  82. #define UA_UINT32_MAX 4294967295
  83. #define UA_UINT32_MIN 0
  84. /** @brief An integer value between -10 223 372 036 854 775 808 and 9 223 372 036 854 775 807 */
  85. typedef int64_t UA_Int64;
  86. #define UA_INT64_MAX 9223372036854775807
  87. #define UA_INT64_MIN -9223372036854775808
  88. /** @brief An integer value between 0 and 18 446 744 073 709 551 615. */
  89. typedef uint64_t UA_UInt64;
  90. #define UA_UINT64_MAX = 18446744073709551615
  91. #define UA_UINT64_MIN = 0
  92. /** @brief An IEEE single precision (32 bit) floating point value. */
  93. typedef float UA_Float;
  94. /** @brief An IEEE double precision (64 bit) floating point value. */
  95. typedef double UA_Double;
  96. /** @brief A sequence of Unicode characters. */
  97. typedef struct {
  98. UA_Int32 length;
  99. UA_Byte *data;
  100. } UA_String;
  101. /** @brief An instance in time.
  102. * A DateTime value is encoded as a 64-bit signed integer which represents the
  103. * number of 100 nanosecond intervals since January 1, 1601 (UTC).
  104. */
  105. typedef UA_Int64 UA_DateTime; // 100 nanosecond resolution
  106. /** @brief A 16 byte value that can be used as a globally unique identifier. */
  107. typedef struct {
  108. UA_UInt32 data1;
  109. UA_UInt16 data2;
  110. UA_UInt16 data3;
  111. UA_Byte data4[8];
  112. } UA_Guid;
  113. /** @brief A sequence of octets. */
  114. typedef UA_String UA_ByteString;
  115. /** @brief An XML element. */
  116. typedef UA_String UA_XmlElement;
  117. /** @brief An identifier for a node in the address space of an OPC UA Server. */
  118. /* The shortened numeric types are introduced during encoding. */
  119. typedef struct {
  120. UA_UInt16 namespaceIndex;
  121. enum {
  122. UA_NODEIDTYPE_NUMERIC = 2,
  123. UA_NODEIDTYPE_STRING = 3,
  124. UA_NODEIDTYPE_GUID = 4,
  125. UA_NODEIDTYPE_BYTESTRING = 5
  126. } identifierType;
  127. union {
  128. UA_UInt32 numeric;
  129. UA_String string;
  130. UA_Guid guid;
  131. UA_ByteString byteString;
  132. } identifier;
  133. } UA_NodeId;
  134. /** @brief A NodeId that allows the namespace URI to be specified instead of an index. */
  135. typedef struct {
  136. UA_NodeId nodeId;
  137. UA_String namespaceUri; // not encoded if length=-1
  138. UA_UInt32 serverIndex; // not encoded if 0
  139. } UA_ExpandedNodeId;
  140. #include "ua_statuscodes.h"
  141. /** @brief A numeric identifier for a error or condition that is associated with a value or an operation. */
  142. typedef enum UA_StatusCode UA_StatusCode; // StatusCodes aren't an enum(=int) since 32 unsigned bits are needed. See also ua_statuscodes.h */
  143. /** @brief A name qualified by a namespace. */
  144. typedef struct {
  145. UA_UInt16 namespaceIndex;
  146. UA_String name;
  147. } UA_QualifiedName;
  148. /** @brief Human readable text with an optional locale identifier. */
  149. typedef struct {
  150. UA_String locale;
  151. UA_String text;
  152. } UA_LocalizedText;
  153. /** @brief A structure that contains an application specific data type that may
  154. not be recognized by the receiver. */
  155. typedef struct {
  156. UA_NodeId typeId;
  157. enum {
  158. UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED = 0,
  159. UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING = 1,
  160. UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISXML = 2
  161. } encoding;
  162. UA_ByteString body; // contains either the bytestring or a pointer to the memory-object
  163. } UA_ExtensionObject;
  164. struct UA_DataType;
  165. typedef struct UA_DataType UA_DataType;
  166. /** @brief NumericRanges are used select a subset in a (multidimensional) variant array.
  167. NumericRange has no official type structure in the standard. Officially, it only exists as an
  168. encoded string, such as "1:2,0:3,5". The colon separates min/max index and the comma separates
  169. dimensions. A single value indicates a range with a single element (min==max). */
  170. typedef struct {
  171. UA_Int32 dimensionsSize;
  172. struct UA_NumericRangeDimension {
  173. UA_UInt32 min;
  174. UA_UInt32 max;
  175. } *dimensions;
  176. } UA_NumericRange;
  177. /** @brief Variants store (arrays of) any data type. Either they provide a pointer to the data in
  178. memory, or functions from which the data can be accessed. Variants are replaced together with
  179. the data they store (exception: use a data source).*/
  180. typedef struct {
  181. const UA_DataType *type;
  182. enum {
  183. UA_VARIANT_DATA, ///< The data is "owned" by this variant (copied and deleted together)
  184. UA_VARIANT_DATA_NODELETE, /**< The data is "borrowed" by the variant and shall not be
  185. deleted at the end of this variant's lifecycle. It is not
  186. possible to overwrite borrowed data due to concurrent access.
  187. Use a custom datasource with a mutex. */
  188. } storageType;
  189. UA_Int32 arrayLength; ///< the number of elements in the data-pointer
  190. void *dataPtr; ///< points to the scalar or array data
  191. UA_Int32 arrayDimensionsSize; ///< the number of dimensions the data-array has
  192. UA_Int32 *arrayDimensions; ///< the length of each dimension of the data-array
  193. } UA_Variant;
  194. /** @brief A data value with an associated status code and timestamps. */
  195. typedef struct {
  196. UA_Boolean hasVariant : 1;
  197. UA_Boolean hasStatus : 1;
  198. UA_Boolean hasSourceTimestamp : 1;
  199. UA_Boolean hasServerTimestamp : 1;
  200. UA_Boolean hasSourcePicoseconds : 1;
  201. UA_Boolean hasServerPicoseconds : 1;
  202. UA_Variant value;
  203. UA_StatusCode status;
  204. UA_DateTime sourceTimestamp;
  205. UA_Int16 sourcePicoseconds;
  206. UA_DateTime serverTimestamp;
  207. UA_Int16 serverPicoseconds;
  208. } UA_DataValue;
  209. /** @brief A structure that contains detailed error and diagnostic information associated with a StatusCode. */
  210. typedef struct UA_DiagnosticInfo {
  211. UA_Boolean hasSymbolicId : 1;
  212. UA_Boolean hasNamespaceUri : 1;
  213. UA_Boolean hasLocalizedText : 1;
  214. UA_Boolean hasLocale : 1;
  215. UA_Boolean hasAdditionalInfo : 1;
  216. UA_Boolean hasInnerStatusCode : 1;
  217. UA_Boolean hasInnerDiagnosticInfo : 1;
  218. UA_Int32 symbolicId;
  219. UA_Int32 namespaceUri;
  220. UA_Int32 localizedText;
  221. UA_Int32 locale;
  222. UA_String additionalInfo;
  223. UA_StatusCode innerStatusCode;
  224. struct UA_DiagnosticInfo *innerDiagnosticInfo;
  225. } UA_DiagnosticInfo;
  226. #ifndef SWIG
  227. #define UA_TYPE_HANDLING_FUNCTIONS(TYPE) \
  228. TYPE UA_EXPORT * TYPE##_new(void); \
  229. void UA_EXPORT TYPE##_init(TYPE * p); \
  230. void UA_EXPORT TYPE##_delete(TYPE * p); \
  231. void UA_EXPORT TYPE##_deleteMembers(TYPE * p); \
  232. UA_StatusCode UA_EXPORT TYPE##_copy(const TYPE *src, TYPE *dst);
  233. #else
  234. #define UA_TYPE_HANDLING_FUNCTIONS(TYPE)
  235. #endif
  236. /* Functions for all types */
  237. UA_TYPE_HANDLING_FUNCTIONS(UA_Boolean)
  238. UA_TYPE_HANDLING_FUNCTIONS(UA_SByte)
  239. UA_TYPE_HANDLING_FUNCTIONS(UA_Byte)
  240. UA_TYPE_HANDLING_FUNCTIONS(UA_Int16)
  241. UA_TYPE_HANDLING_FUNCTIONS(UA_UInt16)
  242. UA_TYPE_HANDLING_FUNCTIONS(UA_Int32)
  243. UA_TYPE_HANDLING_FUNCTIONS(UA_UInt32)
  244. UA_TYPE_HANDLING_FUNCTIONS(UA_Int64)
  245. UA_TYPE_HANDLING_FUNCTIONS(UA_UInt64)
  246. UA_TYPE_HANDLING_FUNCTIONS(UA_Float)
  247. UA_TYPE_HANDLING_FUNCTIONS(UA_Double)
  248. UA_TYPE_HANDLING_FUNCTIONS(UA_String)
  249. #define UA_DateTime_new UA_Int64_new
  250. #define UA_DateTime_init UA_Int64_init
  251. #define UA_DateTime_delete UA_Int64_delete
  252. #define UA_DateTime_deleteMembers UA_Int64_deleteMembers
  253. #define UA_DateTime_copy UA_Int64_copy
  254. UA_TYPE_HANDLING_FUNCTIONS(UA_Guid)
  255. #define UA_ByteString_new UA_String_new
  256. #define UA_ByteString_init UA_String_init
  257. #define UA_ByteString_delete UA_String_delete
  258. #define UA_ByteString_deleteMembers UA_String_deleteMembers
  259. #define UA_ByteString_copy UA_String_copy
  260. #define UA_XmlElement_new UA_String_new
  261. #define UA_XmlElement_init UA_String_init
  262. #define UA_XmlElement_delete UA_String_delete
  263. #define UA_XmlElement_deleteMembers UA_String_deleteMembers
  264. #define UA_XmlElement_copy UA_String_copy
  265. UA_TYPE_HANDLING_FUNCTIONS(UA_NodeId)
  266. UA_TYPE_HANDLING_FUNCTIONS(UA_ExpandedNodeId)
  267. #define UA_StatusCode_new(p) UA_Int32_new((UA_Int32*)p)
  268. #define UA_StatusCode_init(p) UA_Int32_init((UA_Int32*)p)
  269. #define UA_StatusCode_delete(p) UA_Int32_delete((UA_Int32*)p)
  270. #define UA_StatusCode_deleteMembers(p) UA_Int32_deleteMembers((UA_Int32*)p)
  271. #define UA_StatusCode_copy(p) UA_Int32_copy((UA_Int32*)p)
  272. UA_TYPE_HANDLING_FUNCTIONS(UA_QualifiedName)
  273. UA_TYPE_HANDLING_FUNCTIONS(UA_LocalizedText)
  274. UA_TYPE_HANDLING_FUNCTIONS(UA_ExtensionObject)
  275. UA_TYPE_HANDLING_FUNCTIONS(UA_DataValue)
  276. UA_TYPE_HANDLING_FUNCTIONS(UA_Variant)
  277. UA_TYPE_HANDLING_FUNCTIONS(UA_DiagnosticInfo)
  278. /**********************************************/
  279. /* Custom functions for the builtin datatypes */
  280. /**********************************************/
  281. #ifdef __cplusplus
  282. #define CPP_ONLY(STR) STR
  283. #else
  284. #define CPP_ONLY(STR)
  285. #endif
  286. /* String */
  287. /** Copy a (zero terminated) char-array into a UA_String. Memory for the string data is
  288. allocated. */
  289. UA_StatusCode UA_EXPORT UA_String_copycstring(char const *src, UA_String *dst);
  290. /** Printf a char-array into a UA_String. Memory for the string data is allocated. */
  291. UA_StatusCode UA_EXPORT UA_String_copyprintf(char const *fmt, UA_String *dst, ...);
  292. /** Compares two strings */
  293. UA_Boolean UA_EXPORT UA_String_equal(const UA_String *string1, const UA_String *string2);
  294. #define UA_STRING_NULL (UA_String) {-1, (UA_Byte*)0 }
  295. #define UA_STRING_ASSIGN(VARIABLE, STRING) do { \
  296. VARIABLE.length = sizeof(STRING)-1; \
  297. VARIABLE.data = (UA_Byte *)STRING; } while(0)
  298. /* DateTime */
  299. /** Returns the current time */
  300. UA_DateTime UA_EXPORT UA_DateTime_now(void);
  301. typedef struct UA_DateTimeStruct {
  302. UA_Int16 nanoSec;
  303. UA_Int16 microSec;
  304. UA_Int16 milliSec;
  305. UA_Int16 sec;
  306. UA_Int16 min;
  307. UA_Int16 hour;
  308. UA_Int16 day;
  309. UA_Int16 month;
  310. UA_Int16 year;
  311. } UA_DateTimeStruct;
  312. UA_DateTimeStruct UA_EXPORT UA_DateTime_toStruct(UA_DateTime time);
  313. UA_StatusCode UA_EXPORT UA_DateTime_toString(UA_DateTime time, UA_String *timeString);
  314. /* Guid */
  315. /** Compares two guids */
  316. UA_Boolean UA_EXPORT UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2);
  317. /** Returns a randomly generated guid. Do not use for security-critical entropy! */
  318. UA_Guid UA_EXPORT UA_Guid_random(UA_UInt32 *seed);
  319. /* ByteString */
  320. #define UA_ByteString_equal(string1, string2) \
  321. UA_String_equal((const UA_String*) string1, (const UA_String*)string2)
  322. /** Allocates memory of size length for the bytestring. The content is not set to zero. */
  323. UA_StatusCode UA_EXPORT UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length);
  324. /* NodeId */
  325. /** Compares two nodeids */
  326. UA_Boolean UA_EXPORT UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2);
  327. /** Is the nodeid a null-nodeid? */
  328. UA_Boolean UA_EXPORT UA_NodeId_isNull(const UA_NodeId *p);
  329. #define UA_NODEID_ASSIGN(VARIABLE, NAMESPACE, NUMERICID) do { \
  330. VARIABLE.namespaceIndex = NAMESPACE; \
  331. VARIABLE.identifierType = CPP_ONLY(UA_NodeId::)UA_NODEIDTYPE_NUMERIC; \
  332. VARIABLE.identifier.numeric = NUMERICID; } while(0);
  333. #define UA_NODEID_STATIC(NAMESPACE, NUMERICID) (UA_NodeId) { \
  334. .namespaceIndex = NAMESPACE, .identifierType = UA_NODEIDTYPE_NUMERIC, \
  335. .identifier.numeric = NUMERICID }
  336. #define UA_NODEID_NULL UA_NODEID_STATIC(0,0)
  337. /* ExpandedNodeId */
  338. UA_Boolean UA_EXPORT UA_ExpandedNodeId_isNull(const UA_ExpandedNodeId *p);
  339. #define UA_EXPANDEDNODEID_STATIC(NAMESPACE, NUMERICID) (UA_ExpandedNodeId) { \
  340. .nodeId = {.namespaceIndex = NAMESPACE, .identifierType = UA_NODEIDTYPE_NUMERIC, \
  341. .identifier.numeric = NUMERICID }, \
  342. .serverIndex = 0, .namespaceUri = {.data = (UA_Byte*)0, .length = -1} }
  343. /* QualifiedName */
  344. UA_StatusCode UA_EXPORT UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst);
  345. #define UA_QUALIFIEDNAME_ASSIGN(VARIABLE, STRING) do { \
  346. VARIABLE.namespaceIndex = 0; \
  347. UA_STRING_ASSIGN(VARIABLE.name, STRING); } while(0)
  348. /* LocalizedText */
  349. /** Copy a (zero-terminated) char-array into the UA_LocalizedText. Memory for the string is
  350. allocated. The locale is set to "en" by default. */
  351. UA_StatusCode UA_EXPORT UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst);
  352. /* Variant */
  353. /**
  354. * Variant semantics:
  355. * - arrayLength = -1 && dataPtr == NULL: empty variant
  356. * - arrayLength = -1 && dataPtr == !NULL: variant holds a single element (a scalar)
  357. * - arrayLength >= 0: variant holds an array of the appropriate length
  358. * : dataPtr can be NULL if arrayLength == 0
  359. */
  360. /**
  361. * Copy the variant, but use only a subset of the (multidimensional) array. Returns an error code if
  362. * the variant is no array or if the indicated range does not fit.
  363. */
  364. UA_StatusCode UA_EXPORT UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, UA_NumericRange range);
  365. /**
  366. * Set the variant to a scalar value that already resides in memory. The value takes on the
  367. * lifecycle of the variant and is deleted with it.
  368. *
  369. * @param v The variant
  370. * @param p A pointer to the value data
  371. * @param type The datatype of the value in question
  372. * @return Indicates whether the operation succeeded or returns an error code
  373. */
  374. UA_StatusCode UA_EXPORT UA_Variant_setValue(UA_Variant *v, void *p, const UA_DataType *type);
  375. /**
  376. * Set the variant to a scalar value that is copied from an existing variable.
  377. *
  378. * @param v The variant
  379. * @param p A pointer to the value data
  380. * @param type The datatype of the value
  381. * @return Indicates whether the operation succeeded or returns an error code
  382. */
  383. UA_StatusCode UA_EXPORT UA_Variant_copySetValue(UA_Variant *v, const void *p, const UA_DataType *type);
  384. /**
  385. * Set the variant to an array that already resides in memory. The array takes on the lifecycle of
  386. * the variant and is deleted with it.
  387. *
  388. * @param v The variant
  389. * @param array A pointer to the array data
  390. * @param noElements The size of the array
  391. * @param type The datatype of the array
  392. * @return Indicates whether the operation succeeded or returns an error code
  393. */
  394. UA_StatusCode UA_EXPORT UA_Variant_setArray(UA_Variant *v, void *array,
  395. UA_Int32 noElements, const UA_DataType *type);
  396. /**
  397. * Set the variant to an array that is copied from an existing array.
  398. *
  399. * @param v The variant
  400. * @param array A pointer to the array data
  401. * @param noElements The size of the array
  402. * @param type The datatype of the array
  403. * @return Indicates whether the operation succeeded or returns an error code
  404. */
  405. UA_StatusCode UA_EXPORT UA_Variant_copySetArray(UA_Variant *v, const void *array,
  406. UA_Int32 noElements, const UA_DataType *type);
  407. /****************************/
  408. /* Structured Type Handling */
  409. /****************************/
  410. #define UA_MAX_TYPE_MEMBERS 13 // Maximum number of members per complex type
  411. #ifndef _WIN32
  412. # define UA_BITFIELD(SIZE) : SIZE
  413. #else
  414. # define UA_BITFIELD(SIZE)
  415. #endif
  416. #define UA_IS_BUILTIN(ID) (ID <= UA_TYPES_DIAGNOSTICINFO)
  417. typedef struct {
  418. UA_UInt16 memberTypeIndex UA_BITFIELD(9); ///< Index of the member in the datatypetable
  419. UA_Boolean namespaceZero UA_BITFIELD(1); /**< The type of the member is defined in namespace
  420. zero. In this implementation, types from custom
  421. namespace may contain members from the same
  422. namespace or ns0 only.*/
  423. UA_Byte padding UA_BITFIELD(5); /**< How much padding is there before this member element? For
  424. arrays this is split into 2 bytes padding for for the
  425. length index (max 4 bytes) and 3 bytes padding for the
  426. pointer (max 8 bytes) */
  427. UA_Boolean isArray UA_BITFIELD(1); ///< The member is an array of the given type
  428. } UA_DataTypeMember;
  429. struct UA_DataType {
  430. UA_NodeId typeId; ///< The nodeid of the type
  431. ptrdiff_t memSize UA_BITFIELD(16); ///< Size of the struct in memory
  432. UA_UInt16 typeIndex UA_BITFIELD(13); ///< Index of the type in the datatypetable
  433. UA_Boolean namespaceZero UA_BITFIELD(1); ///< The type is defined in namespace zero.
  434. UA_Boolean fixedSize UA_BITFIELD(1); ///< The type (and its members) contains no pointers
  435. UA_Boolean zeroCopyable UA_BITFIELD(1); ///< Can the type be copied directly off the stream?
  436. UA_Byte membersSize; ///< How many members does the type have?
  437. UA_DataTypeMember members[UA_MAX_TYPE_MEMBERS];
  438. };
  439. /**
  440. * Allocates and initializes a variable of type dataType
  441. *
  442. * @param dataType The datatype description
  443. * @return Returns the memory location of the variable or (void*)0 if no memory is available
  444. */
  445. void UA_EXPORT * UA_new(const UA_DataType *dataType);
  446. /**
  447. * Initializes a variable to default values
  448. *
  449. * @param p The memory location of the variable
  450. * @param dataType The datatype description
  451. */
  452. void UA_EXPORT UA_init(void *p, const UA_DataType *dataType);
  453. /**
  454. * Copies the content of two variables. If copying fails (e.g. because no memory was available for
  455. * an array), then dst is emptied and initialized to prevent memory leaks.
  456. *
  457. * @param src The memory location of the source variable
  458. * @param dst The memory location of the destination variable
  459. * @param dataType The datatype description
  460. * @return Indicates whether the operation succeeded or returns an error code
  461. */
  462. UA_StatusCode UA_EXPORT UA_copy(const void *src, void *dst, const UA_DataType *dataType);
  463. /**
  464. * Deletes the dynamically assigned content of a variable (e.g. a member-array). Afterwards, the
  465. * variable can be safely deleted without causing memory leaks. But the variable is not initialized
  466. * and may contain old data that is not memory-relevant.
  467. *
  468. * @param p The memory location of the variable
  469. * @param dataType The datatype description of the variable
  470. */
  471. void UA_EXPORT UA_deleteMembers(void *p, const UA_DataType *dataType);
  472. /**
  473. * Deletes (frees) a variable and all of its content.
  474. *
  475. * @param p The memory location of the variable
  476. * @param dataType The datatype description of the variable
  477. */
  478. void UA_EXPORT UA_delete(void *p, const UA_DataType *dataType);
  479. /********************/
  480. /* Array operations */
  481. /********************/
  482. #define MAX_ARRAY_SIZE 104857600 // arrays must be smaller than 100MB
  483. /**
  484. * Allocates and initializes an array of variables of a specific type
  485. *
  486. * @param dataType The datatype description
  487. * @return Returns the memory location of the variable or (void*)0 if no memory could be allocated
  488. */
  489. void UA_EXPORT * UA_Array_new(const UA_DataType *dataType, UA_Int32 noElements);
  490. /**
  491. * Allocates and copies an array. dst is set to (void*)0 if not enough memory is available.
  492. *
  493. * @param src The memory location of the souce array
  494. * @param dst The memory location where the pointer to the destination array is written
  495. * @param dataType The datatype of the array members
  496. * @param noElements The size of the array
  497. * @return Indicates whether the operation succeeded or returns an error code
  498. */
  499. UA_StatusCode UA_EXPORT UA_Array_copy(const void *src, void **dst, const UA_DataType *dataType, UA_Int32 noElements);
  500. /**
  501. * Deletes an array.
  502. *
  503. * @param src The memory location of the array
  504. * @param dataType The datatype of the array members
  505. * @param noElements The size of the array
  506. */
  507. void UA_EXPORT UA_Array_delete(void *p, const UA_DataType *dataType, UA_Int32 noElements);
  508. /** @} */
  509. #ifdef __cplusplus
  510. } // extern "C"
  511. #endif
  512. #endif /* UA_TYPES_H_ */