source: azure_iot_hub_f767zi/trunk/azure_iot_sdk/serializer/inc/serializer.h@ 457

Last change on this file since 457 was 457, checked in by coas-nagasima, 4 years ago

ファイルを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-chdr;charset=UTF-8
File size: 60.2 KB
Line 
1// Copyright (c) Microsoft. All rights reserved.
2// Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4/** @file serializer.h
5* @brief The IoT Hub Serializer APIs allows developers to define models for
6* their devices
7*
8* @details The IoT Hub Serializer APIs allows developers to quickly and easily define
9* models for their devices directly as code, while supporting the required
10* features for modeling devices (including multiple models and multiple
11* devices within the same application). For example:
12*
13* <pre>
14* BEGIN_NAMESPACE(Contoso);
15*
16* DECLARE_STRUCT(SystemProperties,
17* ascii_char_ptr, DeviceID,
18* _Bool, Enabled
19* );
20*
21* DECLARE_MODEL(VendingMachine,
22*
23* WITH_DATA(int, SensorValue),
24*
25* WITH_DATA(ascii_char_ptr, ObjectName),
26* WITH_DATA(ascii_char_ptr, ObjectType),
27* WITH_DATA(ascii_char_ptr, Version),
28* WITH_DATA(SystemProperties, SystemProperties),
29* WITH_DATA(ascii_char_ptr_no_quotes, Commands),
30*
31* WITH_ACTION(SetItemPrice, ascii_char_ptr, itemId, ascii_char_ptr, price)
32* );
33*
34* END_NAMESPACE(Contoso);
35* </pre>
36*/
37
38#ifndef SERIALIZER_H
39#define SERIALIZER_H
40
41#ifdef __cplusplus
42#include <cstdlib>
43#include <cstdarg>
44
45#else
46#include <stdlib.h>
47#include <stdarg.h>
48#endif
49
50#include "azure_c_shared_utility/gballoc.h"
51#include "azure_macro_utils/macro_utils.h"
52#include "iotdevice.h"
53#include "azure_c_shared_utility/crt_abstractions.h"
54#include "azure_c_shared_utility/xlogging.h"
55#include "methodreturn.h"
56#include "schemalib.h"
57#include "codefirst.h"
58#include "agenttypesystem.h"
59#include "schema.h"
60
61
62
63#ifdef __cplusplus
64extern "C"
65{
66#endif
67
68 /* IOT Agent Macros */
69
70 /**
71 * @def BEGIN_NAMESPACE(schemaNamespace)
72 * This macro marks the start of a section that declares IOT model
73 * elements (like complex types, etc.). Declarations are typically
74 * placed in header files, so that they can be shared between
75 * translation units.
76 */
77 /* Codes_SRS_SERIALIZER_99_001:[For each completed schema declaration block, a unique storage container for schema metadata shall be available in the translation unit at runtime.] */
78#define BEGIN_NAMESPACE(schemaNamespace) \
79 REFLECTED_END_OF_LIST
80
81/**
82* @def END_NAMESPACE(schemaNamespace)
83* This macro marks the end of a section that declares IOT model
84* elements.
85*/
86#define END_NAMESPACE(schemaNamespace) \
87 REFLECTED_LIST_HEAD(schemaNamespace)
88
89#define GLOBAL_INITIALIZE_STRUCT_FIELD(structType, destination, type, name) GlobalInitialize_##type((char*)destination+offsetof(structType, name));
90#define GLOBAL_DEINITIALIZE_STRUCT_FIELD(structType, destination, type, name) GlobalDeinitialize_##type((char*)destination+offsetof(structType, name));
91/**
92* @def DECLARE_STRUCT(name, ...)
93* This macro allows the definition of a struct type that can then be used as
94* part of a model definition.
95*
96* @param name Name of the struct
97* @param element1, element2... Specifies a list of struct members
98*/
99/* Codes_SRS_SERIALIZER_99_080:[ The DECLARE_STRUCT declaration shall insert metadata describing a complex data type.] */
100#define DECLARE_STRUCT(name, ...) \
101 /* Codes_SRS_SERIALIZER_99_096:[ DECLARE_STRUCT shall declare a matching C struct data type named name, which can be referenced from any code that can access the declaration.] */ \
102 typedef struct name##_TAG { \
103 MU_FOR_EACH_2(INSERT_FIELD_INTO_STRUCT, __VA_ARGS__) \
104 } name; \
105 /* Codes_SRS_SERIALIZER_99_081:[ DECLARE_STRUCT's name argument shall uniquely identify the struct within the schema.] */ \
106 REFLECTED_STRUCT(name) \
107 /* Codes_SRS_SERIALIZER_99_082:[ DECLARE_STRUCT's field<n>Name argument shall uniquely name a field within the struct.] */ \
108 MU_FOR_EACH_2_KEEP_1(REFLECTED_FIELD, name, __VA_ARGS__) \
109 TO_AGENT_DATA_TYPE(name, __VA_ARGS__) \
110 /*Codes_SRS_SERIALIZER_99_042:[ The parameter types are either predefined parameter types (specs SRS_SERIALIZER_99_004-SRS_SERIALIZER_99_014) or a type introduced by DECLARE_STRUCT.]*/ \
111 static AGENT_DATA_TYPES_RESULT FromAGENT_DATA_TYPE_##name(const AGENT_DATA_TYPE* source, name* destination) \
112 { \
113 AGENT_DATA_TYPES_RESULT result; \
114 if(source->type != EDM_COMPLEX_TYPE_TYPE) \
115 { \
116 result = AGENT_DATA_TYPES_INVALID_ARG; \
117 } \
118 else if(MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)) != source->value.edmComplexType.nMembers) \
119 { \
120 /*too many or too few fields*/ \
121 result = AGENT_DATA_TYPES_INVALID_ARG; \
122 } \
123 else \
124 { \
125 result = AGENT_DATA_TYPES_OK; \
126 MU_FOR_EACH_2(BUILD_DESTINATION_FIELD, __VA_ARGS__); \
127 } \
128 return result; \
129 } \
130 static void MU_C2(destroyLocalParameter, name)(name * value) \
131 { \
132 MU_FOR_EACH_2_KEEP_1(UNBUILD_DESTINATION_FIELD, value, __VA_ARGS__); \
133 } \
134 static void MU_C2(GlobalInitialize_, name)(void* destination) \
135 { \
136 MU_FOR_EACH_2_KEEP_2(GLOBAL_INITIALIZE_STRUCT_FIELD, name, destination, __VA_ARGS__); \
137 } \
138 static void MU_C2(GlobalDeinitialize_, name)(void* destination) \
139 { \
140 MU_FOR_EACH_2_KEEP_2(GLOBAL_DEINITIALIZE_STRUCT_FIELD, name, destination, __VA_ARGS__); \
141 } \
142
143
144/**
145 * @def DECLARE_MODEL(name, ...)
146 * This macro allows declaring a model that can be later used to instantiate
147 * a device.
148 *
149 * @param name Specifies the model name
150 * @param element1, element2... Specifies a model element which can be
151 * a property or an action.
152 * - A property is described in a
153 * model by using the WITH_DATA
154 * - An action is described in a
155 * model by using the ::WITH_ACTION
156 * macro.
157 *
158 */
159 /* WITH_DATA's name argument shall be one of the following data types: */
160 /* Codes_SRS_SERIALIZER_99_133:[a model type introduced previously by DECLARE_MODEL] */
161
162#define CREATE_DESIRED_PROPERTY_CALLBACK_MODEL_ACTION(...)
163#define CREATE_DESIRED_PROPERTY_CALLBACK_MODEL_METHOD(...)
164#define CREATE_DESIRED_PROPERTY_CALLBACK_MODEL_DESIRED_PROPERTY(type, name, ...) MU_IF(MU_COUNT_ARG(__VA_ARGS__), void __VA_ARGS__ (void*);, )
165#define CREATE_DESIRED_PROPERTY_CALLBACK_MODEL_PROPERTY(...)
166#define CREATE_DESIRED_PROPERTY_CALLBACK_MODEL_REPORTED_PROPERTY(...)
167
168#define CREATE_DESIRED_PROPERTY_CALLBACK(...) CREATE_DESIRED_PROPERTY_CALLBACK_##__VA_ARGS__
169
170#define SERIALIZER_REGISTER_NAMESPACE(NAMESPACE) CodeFirst_RegisterSchema(#NAMESPACE, & ALL_REFLECTED(NAMESPACE))
171
172#define DECLARE_MODEL(name, ...) \
173 REFLECTED_MODEL(name) \
174 MU_FOR_EACH_1(CREATE_DESIRED_PROPERTY_CALLBACK, __VA_ARGS__) \
175 typedef struct name { int :1; MU_FOR_EACH_1(BUILD_MODEL_STRUCT, __VA_ARGS__) } name; \
176 MU_FOR_EACH_1_KEEP_1(CREATE_MODEL_ELEMENT, name, __VA_ARGS__) \
177 TO_AGENT_DATA_TYPE(name, DROP_FIRST_COMMA_FROM_ARGS(EXPAND_MODEL_ARGS(__VA_ARGS__))) \
178 int FromAGENT_DATA_TYPE_##name(const AGENT_DATA_TYPE* source, void* destination) \
179 { \
180 (void)source; \
181 (void)destination; \
182 LogError("SHOULD NOT GET CALLED... EVER"); \
183 return 0; \
184 } \
185 static void MU_C2(GlobalInitialize_, name)(void* destination) \
186 { \
187 (void)destination; \
188 MU_FOR_EACH_1_KEEP_1(CREATE_MODEL_ELEMENT_GLOBAL_INITIALIZE, name, __VA_ARGS__) \
189 } \
190 static void MU_C2(GlobalDeinitialize_, name)(void* destination) \
191 { \
192 (void)destination; \
193 MU_FOR_EACH_1_KEEP_1(CREATE_MODEL_ELEMENT_GLOBAL_DEINITIALIZE, name, __VA_ARGS__) \
194 } \
195
196
197
198/**
199 * @def WITH_DATA(type, name)
200 * The ::WITH_DATA macro allows declaring a model property in a model. A
201 * property can be published by using the ::SERIALIZE macro.
202 *
203 * @param type Specifies the property type. Can be any of the following
204 * types:
205 * - int
206 * - double
207 * - float
208 * - long
209 * - int8_t
210 * - uint8_t
211 * - int16_t
212 * - int32_t
213 * - int64_t
214 * - bool
215 * - ascii_char_ptr
216 * - EDM_DATE_TIME_OFFSET
217 * - EDM_GUID
218 * - EDM_BINARY
219 * - Any struct type previously introduced by another ::DECLARE_STRUCT.
220 *
221 * @param name Specifies the property name
222 */
223#define WITH_DATA(type, name) MODEL_PROPERTY(type, name)
224
225
226#define WITH_REPORTED_PROPERTY(type, name) MODEL_REPORTED_PROPERTY(type, name)
227
228#define WITH_DESIRED_PROPERTY(type, name, ...) MODEL_DESIRED_PROPERTY(type, name, __VA_ARGS__)
229
230/**
231 * @def WITH_ACTION(name, ...)
232 * The ::WITH_ACTION macro allows declaring a model action.
233 *
234 * @param name Specifies the action name.
235 * @param argXtype, argXName... Defines the type and name for the X<sup>th</sup>
236 * argument of the action. The type can be any of
237 * the primitive types or a struct type.
238 */
239/*Codes_SRS_SERIALIZER_99_039:[WITH_ACTION shall declare an action of the current data provider called as the first macro parameter(name) and having the first parameter called parameter1Name of type parameter1Type, the second parameter named parameter2Name having the type parameter2Type and so on.]*/
240#define WITH_ACTION(name, ...) MODEL_ACTION(name, __VA_ARGS__)
241
242
243/**
244* @def WITH_METHOD(name, ...)
245* The ::WITH_METHOD macro allows declaring a model method.
246*
247* @param name Specifies the method name.
248* @param argXtype, argXName... Defines the type and name for the X<sup>th</sup>
249* argument of the method. The type can be any of
250* the primitive types or a struct type.
251*/
252/*Codes_SRS_SERIALIZER_H_02_029: [ WITH_METHOD shall declare a function with the signature 'METHODRETURN_HANDLE name(param1Type param1Name, ...)', which the developer can define to receive corresponding commands from the IoT service. ]*/
253#define WITH_METHOD(name, ...) MODEL_METHOD(name, __VA_ARGS__)
254
255
256/**
257 * @def GET_MODEL_HANDLE(schemaNamespace, modelName)
258 * The ::GET_MODEL_HANDLE macro returns a model handle that can be used in
259 * subsequent operations like generating the CSDL schema for the model,
260 * uploading the schema, creating a device, etc.
261 *
262 * @param schemaNamespace The namespace to which the model belongs.
263 * @param modelName The name of the model.
264 */
265/* Codes_SRS_SERIALIZER_99_110:[ The GET_MODEL_HANDLE function macro shall first register the schema by calling CodeFirst_RegisterSchema, passing schemaNamespace and a pointer to the metadata generated in the schema declaration block.] */
266/* Codes_SRS_SERIALIZER_99_094:[ GET_MODEL_HANDLE shall then call Schema_GetModelByName, passing the schemaHandle obtained from CodeFirst_RegisterSchema and modelName arguments, to retrieve the SCHEMA_MODEL_TYPE_HANDLE corresponding to the modelName argument.] */
267/* Codes_SRS_SERIALIZER_99_112:[ GET_MODEL_HANDLE will return the handle for the named model.] */
268#define GET_MODEL_HANDLE(schemaNamespace, modelName) \
269 Schema_GetModelByName(CodeFirst_RegisterSchema(MU_TOSTRING(schemaNamespace), &ALL_REFLECTED(schemaNamespace)), #modelName)
270
271/* Codes_SRS_SERIALIZER_01_002: [If the argument serializerIncludePropertyPath is specified, its value shall be passed to CodeFirst_Create.] */
272#define CREATE_DEVICE_WITH_INCLUDE_PROPERTY_PATH(schemaNamespace, modelName, serializerIncludePropertyPath) \
273 (modelName*)CodeFirst_CreateDevice(GET_MODEL_HANDLE(schemaNamespace, modelName), &ALL_REFLECTED(schemaNamespace), sizeof(modelName), serializerIncludePropertyPath)
274
275/* Codes_SRS_SERIALIZER_01_003: [If the argument serializerIncludePropertyPath is not specified, CREATE_MODEL_INSTANCE shall pass false to CodeFirst_Create.] */
276#define CREATE_DEVICE_WITHOUT_INCLUDE_PROPERTY_PATH(schemaNamespace, modelName) \
277 (modelName*)CodeFirst_CreateDevice(GET_MODEL_HANDLE(schemaNamespace, modelName), &ALL_REFLECTED(schemaNamespace), sizeof(modelName), false)
278
279/* Codes_SRS_SERIALIZER_99_104:[ CREATE_MODEL_INSTANCE shall call GET_MODEL_HANDLE, passing schemaNamespace and modelName, to get a model handle representing the model defined in the corresponding schema declaration block.] */
280/* Codes_SRS_SERIALIZER_99_106:[ CREATE_MODEL_INSTANCE shall call CodeFirst_CreateDevice, passing the model handle (SCHEMA_MODEL_TYPE_HANDLE]*/
281/* Codes_SRS_SERIALIZER_99_107:[ If CodeFirst_CreateDevice fails, CREATE_MODEL_INSTANCE shall return NULL.] */
282/* Codes_SRS_SERIALIZER_99_108:[ If CodeFirst_CreateDevice succeeds, CREATE_MODEL_INSTANCE shall return a pointer to an instance of the C struct representing the model for the device.] */
283#define CREATE_MODEL_INSTANCE(schemaNamespace, ...) \
284 MU_IF(MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), CREATE_DEVICE_WITH_INCLUDE_PROPERTY_PATH, CREATE_DEVICE_WITHOUT_INCLUDE_PROPERTY_PATH) (schemaNamespace, __VA_ARGS__)
285
286/* Codes_SRS_SERIALIZER_99_109:[ DESTROY_MODEL_INSTANCE shall call CodeFirst_DestroyDevice, passing the pointer returned from CREATE_MODEL_INSTANCE, to release all resources associated with the device.] */
287#define DESTROY_MODEL_INSTANCE(deviceData) \
288 CodeFirst_DestroyDevice(deviceData)
289
290/**
291 * @def SERIALIZE(destination, destinationSize,...)
292 * This macro produces JSON serialized representation of the properties.
293 *
294 * @param destination Pointer to an @c unsigned @c char* that
295 * will receive the serialized data.
296 * @param destinationSize Pointer to a @c size_t that gets
297 * written with the size in bytes of the
298 * serialized data
299 * @param property1, property2... A list of property values to send. The
300 * order in which the properties appear in
301 * the list does not matter, all values
302 * will be sent together.
303 *
304 */
305/*Codes_SRS_SERIALIZER_99_113:[ SERIALIZE shall call CodeFirst_SendAsync, passing a destination, destinationSize, the number of properties to publish, and pointers to the values for each property.] */
306/*Codes_SRS_SERIALIZER_99_117:[ If CodeFirst_SendAsync succeeds, SEND will return IOT_AGENT_OK.] */
307/*Codes_SRS_SERIALIZER_99_114:[ If CodeFirst_SendAsync fails, SEND shall return IOT_AGENT_SERIALIZE_FAILED.] */
308#define SERIALIZE(destination, destinationSize,...) CodeFirst_SendAsync(destination, destinationSize, MU_COUNT_ARG(__VA_ARGS__) MU_FOR_EACH_1(ADDRESS_MACRO, __VA_ARGS__))
309
310#define SERIALIZE_REPORTED_PROPERTIES(destination, destinationSize,...) CodeFirst_SendAsyncReported(destination, destinationSize, MU_COUNT_ARG(__VA_ARGS__) MU_FOR_EACH_1(ADDRESS_MACRO, __VA_ARGS__))
311
312
313#define IDENTITY_MACRO(x) ,x
314#define SERIALIZE_REPORTED_PROPERTIES_FROM_POINTERS(destination, destinationSize, ...) CodeFirst_SendAsyncReported(destination, destinationSize, MU_COUNT_ARG(__VA_ARGS__) MU_FOR_EACH_1(IDENTITY_MACRO, __VA_ARGS__))
315
316/**
317 * @def EXECUTE_COMMAND(device, command)
318 * Any action that is declared in a model must also have an implementation as
319 * a C function.
320 *
321 * @param device Pointer to device data.
322 * @param command Values that match the arguments declared in the model
323 * action.
324 */
325/*Codes_SRS_SERIALIZER_02_018: [EXECUTE_COMMAND macro shall call CodeFirst_ExecuteCommand passing device, commandBuffer and commandBufferSize.]*/
326#define EXECUTE_COMMAND(device, command) (CodeFirst_ExecuteCommand(device, command))
327
328/**
329* @def EXECUTE_METHOD(device, methodName, methodPayload)
330* Any method that is declared in a model must also have an implementation as
331* a C function.
332*
333* @param device Pointer to device data.
334* @param methodName The method name.
335* @param methodPayload The method payload.
336*/
337#define EXECUTE_METHOD(device, methodName, methodPayload) CodeFirst_ExecuteMethod(device, methodName, methodPayload)
338
339/**
340* @def INGEST_DESIRED_PROPERTIES(device, desiredProperties)
341*
342* @param device return of CodeFirst_CreateDevice.
343* @param desiredProperties a null terminated string containing in JSON format the desired properties
344*/
345#define INGEST_DESIRED_PROPERTIES(device, jsonPayload, parseDesiredNode) (CodeFirst_IngestDesiredProperties(device, jsonPayload, parseDesiredNode))
346
347/* Helper macros */
348
349/* These macros remove a useless comma from the beginning of an argument list that looks like:
350,x1,y1,x2,y2 */
351#ifdef _MSC_VER
352
353#define DROP_FIRST_COMMA(N, x) \
354x MU_IFCOMMA_NOFIRST(N)
355
356#define DROP_IF_EMPTY(N, x) \
357MU_IF(MU_COUNT_ARG(x),DROP_FIRST_COMMA(N,x),x)
358
359#define DROP_FIRST_COMMA_FROM_ARGS(...) \
360MU_FOR_EACH_1_COUNTED(DROP_IF_EMPTY, MU_C1(__VA_ARGS__))
361
362#else
363
364#define DROP_FIRST_COMMA_0(N, x) \
365 x MU_IFCOMMA_NOFIRST(N)
366
367#define DROP_FIRST_COMMA_1(N, x) \
368 x
369
370#define DROP_FIRST_COMMA(empty, N, x) \
371 MU_C2(DROP_FIRST_COMMA_,empty)(N,x)
372
373#define DROP_IF_EMPTY(N, x) \
374 DROP_FIRST_COMMA(MU_ISEMPTY(x),N,x)
375
376#define DROP_FIRST_COMMA_FROM_ARGS(...) \
377 MU_FOR_EACH_1_COUNTED(DROP_IF_EMPTY, __VA_ARGS__)
378
379#endif
380
381/* These macros expand a sequence of arguments for DECLARE_MODEL that looks like
382WITH_DATA(x, y), WITH_DATA(x2, y2) to a list of arguments consumed by the macro that marshalls a struct, like:
383x, y, x2, y2
384Actions are discarded, since no marshalling will be done for those when sending state data */
385#define TO_AGENT_DT_EXPAND_MODEL_PROPERTY(x, y) ,x,y
386
387#define TO_AGENT_DT_EXPAND_MODEL_REPORTED_PROPERTY(x, y) ,x,y
388
389#define TO_AGENT_DT_EXPAND_MODEL_DESIRED_PROPERTY(x, y, ...) ,x,y
390
391#define TO_AGENT_DT_EXPAND_MODEL_ACTION(...)
392
393#define TO_AGENT_DT_EXPAND_MODEL_METHOD(...)
394
395#define TO_AGENT_DT_EXPAND_ELEMENT_ARGS(N, ...) TO_AGENT_DT_EXPAND_##__VA_ARGS__
396
397#define EXPAND_MODEL_ARGS(...) \
398 MU_FOR_EACH_1_COUNTED(TO_AGENT_DT_EXPAND_ELEMENT_ARGS, __VA_ARGS__)
399
400#define TO_AGENT_DATA_TYPE(name, ...) \
401 static AGENT_DATA_TYPES_RESULT ToAGENT_DATA_TYPE_##name(AGENT_DATA_TYPE *destination, const name value) \
402 { \
403 AGENT_DATA_TYPES_RESULT result = AGENT_DATA_TYPES_OK; \
404 size_t iMember = 0; \
405 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(phantomName, 1); \
406 const char* memberNames[MU_IF(MU_DIV2(MU_C1(MU_COUNT_ARG(__VA_ARGS__))), MU_DIV2(MU_C1(MU_COUNT_ARG(__VA_ARGS__))), 1)] = { 0 }; \
407 size_t memberCount = sizeof(memberNames) / sizeof(memberNames[0]); \
408 (void)value; \
409 if (memberCount == 0) \
410 { \
411 result = AGENT_DATA_TYPES_OK; \
412 } \
413 else \
414 { \
415 AGENT_DATA_TYPE members[sizeof(memberNames) / sizeof(memberNames[0])]; \
416 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(phantomName, 2); \
417 MU_FOR_EACH_2(FIELD_AS_STRING, MU_EXPAND_TWICE(__VA_ARGS__)) \
418 iMember = 0; \
419 { \
420 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(phantomName, 3); \
421 MU_FOR_EACH_2(CREATE_AGENT_DATA_TYPE, MU_EXPAND_TWICE(__VA_ARGS__)) \
422 {DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(phantomName, 4); } \
423 result = ((result == AGENT_DATA_TYPES_OK) && (Create_AGENT_DATA_TYPE_from_Members(destination, #name, sizeof(memberNames) / sizeof(memberNames[0]), memberNames, members) == AGENT_DATA_TYPES_OK)) \
424 ? AGENT_DATA_TYPES_OK \
425 : AGENT_DATA_TYPES_ERROR; \
426 { \
427 size_t jMember; \
428 for (jMember = 0; jMember < iMember; jMember++) \
429 { \
430 Destroy_AGENT_DATA_TYPE(&members[jMember]); \
431 } \
432 } \
433 } \
434 } \
435 return result; \
436 }
437
438#define FIELD_AS_STRING(x,y) memberNames[iMember++] = #y;
439
440#define REFLECTED_LIST_HEAD(name) \
441 static const REFLECTED_DATA_FROM_DATAPROVIDER ALL_REFLECTED(name) = { &MU_C2(REFLECTED_, MU_C1(MU_DEC(__COUNTER__))) };
442#define REFLECTED_STRUCT(name) \
443 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_STRUCT_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {0}, {0}, {0}, {MU_TOSTRING(name)}, {0}, {0}, {0}, {0}} };
444#define REFLECTED_FIELD(XstructName, XfieldType, XfieldName) \
445 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_FIELD_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {0}, {0}, {0}, {0}, {MU_TOSTRING(XfieldName), MU_TOSTRING(XfieldType), MU_TOSTRING(XstructName)}, {0}, {0}, {0} } };
446#define REFLECTED_MODEL(name) \
447 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_MODEL_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {0}, {0}, {0}, {0}, {0}, {0}, {0}, {MU_TOSTRING(name)} } };
448#define REFLECTED_PROPERTY(type, name, modelName) \
449 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_PROPERTY_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {0}, {0}, {0}, {0}, {0}, {MU_TOSTRING(name), MU_TOSTRING(type), Create_AGENT_DATA_TYPE_From_Ptr_##modelName##name, offsetof(modelName, name), sizeof(type), MU_TOSTRING(modelName)}, {0}, {0} } };
450#define REFLECTED_REPORTED_PROPERTY(type, name, modelName) \
451 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_REPORTED_PROPERTY_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {0}, {0}, {MU_TOSTRING(name), MU_TOSTRING(type), Create_AGENT_DATA_TYPE_From_Ptr_##modelName##name, offsetof(modelName, name), sizeof(type), MU_TOSTRING(modelName)}, {0}, {0}, {0}, {0}, {0} } };
452
453
454#define REFLECTED_DESIRED_PROPERTY_WITH_ON_DESIRED_PROPERTY_CHANGE(type, name, modelName, COUNTER, onDesiredPropertyChange) \
455 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(COUNTER))) = { REFLECTION_DESIRED_PROPERTY_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(COUNTER))), { {0}, {onDesiredPropertyChange, DesiredPropertyInitialize_##modelName##name, DesiredPropertyDeinitialize_##modelName##name, MU_TOSTRING(name), MU_TOSTRING(type), (int(*)(const AGENT_DATA_TYPE*, void*))FromAGENT_DATA_TYPE_##type, offsetof(modelName, name), sizeof(type), MU_TOSTRING(modelName)}, {0}, {0}, {0}, {0}, {0}, {0}} };
456
457#define REFLECTED_DESIRED_PROPERTY(type, name, modelName, ...) \
458 MU_IF(MU_COUNT_ARG(__VA_ARGS__), \
459 MACRO_UTILS_DELAY(REFLECTED_DESIRED_PROPERTY_WITH_ON_DESIRED_PROPERTY_CHANGE)(type, name, modelName,__COUNTER__, __VA_ARGS__), \
460 MACRO_UTILS_DELAY(REFLECTED_DESIRED_PROPERTY_WITH_ON_DESIRED_PROPERTY_CHANGE)(type, name, modelName,MU_DEC(__COUNTER__), NULL) \
461 ) \
462
463#define REFLECTED_ACTION(name, argc, argv, fn, modelName) \
464 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_ACTION_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {0}, {0}, {0}, {0}, {0}, {0}, {MU_TOSTRING(name), argc, argv, fn, MU_TOSTRING(modelName)}, {0}} };
465
466#define REFLECTED_METHOD(name, argc, argv, fn, modelName) \
467 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, MU_C1(MU_INC(__COUNTER__))) = { REFLECTION_METHOD_TYPE, &MU_C2(REFLECTED_, MU_C1(MU_DEC(MU_DEC(__COUNTER__)))), { {MU_TOSTRING(name), argc, argv, fn, MU_TOSTRING(modelName)}, {0}, {0}, {0}, {0}, {0}, {0}, {0}} };
468
469
470#define REFLECTED_END_OF_LIST \
471 static const REFLECTED_SOMETHING MU_C2(REFLECTED_, __COUNTER__) = { REFLECTION_NOTHING, NULL, { {0},{0}, {0}, {0}, {0}, {0}, {0}, {0}} };
472
473#define EXPAND_MODEL_PROPERTY(type, name) MU_EXPAND_ARGS(MODEL_PROPERTY, type, name)
474
475#define EXPAND_MODEL_REPORTED_PROPERTY(type, name) MU_EXPAND_ARGS(MODEL_REPORTED_PROPERTY, type, name)
476
477#define EXPAND_MODEL_DESIRED_PROPERTY(type, name, ...) MU_EXPAND_ARGS(MODEL_DESIRED_PROPERTY, type, name, __VA_ARGS__)
478
479#define EXPAND_MODEL_ACTION(...) MU_EXPAND_ARGS(MODEL_ACTION, __VA_ARGS__)
480
481#define EXPAND_MODEL_METHOD(...) MU_EXPAND_ARGS(MODEL_METHOD, __VA_ARGS__)
482
483#define BUILD_MODEL_STRUCT(elem) INSERT_FIELD_FOR_##elem
484
485#define CREATE_MODEL_ENTITY(modelName, callType, ...) MU_EXPAND_ARGS(CREATE_##callType(modelName, __VA_ARGS__))
486#define CREATE_SOMETHING(modelName, ...) MU_EXPAND_ARGS(CREATE_MODEL_ENTITY(modelName, __VA_ARGS__))
487#define CREATE_ELEMENT(modelName, elem) MU_EXPAND_ARGS(CREATE_SOMETHING(modelName, MU_EXPAND_ARGS(EXPAND_##elem)))
488
489#define CREATE_MODEL_ELEMENT(modelName, elem) MU_EXPAND_ARGS(CREATE_ELEMENT(modelName, elem))
490
491
492#define CREATE_MODEL_ENTITY_GLOBAL_INITIALIZATION(modelName, callType, ...) MU_EXPAND_ARGS(CREATE_GLOBAL_INITIALIZE_##callType(modelName, __VA_ARGS__))
493#define CREATE_SOMETHING_GLOBAL_INITIALIZATION(modelName, ...) MU_EXPAND_ARGS(CREATE_MODEL_ENTITY_GLOBAL_INITIALIZATION(modelName, __VA_ARGS__))
494#define CREATE_ELEMENT_GLOBAL_INITIALIZATION(modelName, elem) MU_EXPAND_ARGS(CREATE_SOMETHING_GLOBAL_INITIALIZATION(modelName, MU_EXPAND_ARGS(EXPAND_##elem)))
495#define CREATE_MODEL_ELEMENT_GLOBAL_INITIALIZE(modelName, elem) MU_EXPAND_ARGS(CREATE_ELEMENT_GLOBAL_INITIALIZATION(modelName, elem))
496
497#define CREATE_MODEL_ENTITY_GLOBAL_DEINITIALIZATION(modelName, callType, ...) MU_EXPAND_ARGS(CREATE_GLOBAL_DEINITIALIZE_##callType(modelName, __VA_ARGS__))
498#define CREATE_SOMETHING_GLOBAL_DEINITIALIZATION(modelName, ...) MU_EXPAND_ARGS(CREATE_MODEL_ENTITY_GLOBAL_DEINITIALIZATION(modelName, __VA_ARGS__))
499#define CREATE_ELEMENT_GLOBAL_DEINITIALIZATION(modelName, elem) MU_EXPAND_ARGS(CREATE_SOMETHING_GLOBAL_DEINITIALIZATION(modelName, MU_EXPAND_ARGS(EXPAND_##elem)))
500#define CREATE_MODEL_ELEMENT_GLOBAL_DEINITIALIZE(modelName, elem) MU_EXPAND_ARGS(CREATE_ELEMENT_GLOBAL_DEINITIALIZATION(modelName, elem))
501
502#define INSERT_FIELD_INTO_STRUCT(x, y) x y;
503
504
505#define INSERT_FIELD_FOR_MODEL_PROPERTY(type, name) INSERT_FIELD_INTO_STRUCT(type, name)
506#define CREATE_GLOBAL_INITIALIZE_MODEL_PROPERTY(modelName, type, name) /*do nothing, this is written by user*/
507#define CREATE_GLOBAL_DEINITIALIZE_MODEL_PROPERTY(modelName, type, name) /*do nothing, this is user's stuff*/
508
509/*REPORTED_PROPERTY is not different than regular WITH_DATA*/
510#define INSERT_FIELD_FOR_MODEL_REPORTED_PROPERTY(type, name) INSERT_FIELD_INTO_STRUCT(type, name)
511#define CREATE_GLOBAL_INITIALIZE_MODEL_REPORTED_PROPERTY(modelName, type,name) GlobalInitialize_##type((char*)destination+offsetof(modelName, name));
512#define CREATE_GLOBAL_DEINITIALIZE_MODEL_REPORTED_PROPERTY(modelName, type,name) GlobalDeinitialize_##type((char*)destination+offsetof(modelName, name));
513
514/*DESIRED_PROPERTY is not different than regular WITH_DATA*/
515#define INSERT_FIELD_FOR_MODEL_DESIRED_PROPERTY(type, name, ...) INSERT_FIELD_INTO_STRUCT(type, name)
516#define CREATE_GLOBAL_INITIALIZE_MODEL_DESIRED_PROPERTY(modelName, type, name, ...) /*do nothing*/
517#define CREATE_GLOBAL_DEINITIALIZE_MODEL_DESIRED_PROPERTY(modelName, type, name, ...) /*do nothing*/
518
519#define INSERT_FIELD_FOR_MODEL_ACTION(name, ...) /* action isn't a part of the model struct */
520#define INSERT_FIELD_FOR_MODEL_METHOD(name, ...) /* method isn't a part of the model struct */
521
522#define CREATE_GLOBAL_INITIALIZE_MODEL_ACTION(...) /*do nothing*/
523#define CREATE_GLOBAL_DEINITIALIZE_MODEL_ACTION(...) /*do nothing*/
524
525#define CREATE_GLOBAL_INITIALIZE_MODEL_METHOD(...) /*do nothing*/
526#define CREATE_GLOBAL_DEINITIALIZE_MODEL_METHOD(...) /*do nothing*/
527
528#define CREATE_MODEL_PROPERTY(modelName, type, name) \
529 IMPL_PROPERTY(type, name, modelName)
530
531#define CREATE_MODEL_REPORTED_PROPERTY(modelName, type, name) \
532 IMPL_REPORTED_PROPERTY(type, name, modelName)
533
534#define CREATE_MODEL_DESIRED_PROPERTY(modelName, type, name, ...) \
535 IMPL_DESIRED_PROPERTY(type, name, modelName, __VA_ARGS__)
536
537#define IMPL_PROPERTY(propertyType, propertyName, modelName) \
538 static int Create_AGENT_DATA_TYPE_From_Ptr_##modelName##propertyName(void* param, AGENT_DATA_TYPE* dest) \
539 { \
540 return MU_C1(ToAGENT_DATA_TYPE_##propertyType)(dest, *(propertyType*)param); \
541 } \
542 REFLECTED_PROPERTY(propertyType, propertyName, modelName)
543
544#define IMPL_REPORTED_PROPERTY(propertyType, propertyName, modelName) \
545 static int Create_AGENT_DATA_TYPE_From_Ptr_##modelName##propertyName(void* param, AGENT_DATA_TYPE* dest) \
546 { \
547 return MU_C1(ToAGENT_DATA_TYPE_##propertyType)(dest, *(propertyType*)param); \
548 } \
549 REFLECTED_REPORTED_PROPERTY(propertyType, propertyName, modelName)
550
551#define IMPL_DESIRED_PROPERTY(propertyType, propertyName, modelName, ...) \
552 static void DesiredPropertyInitialize_##modelName##propertyName(void* destination) \
553 { \
554 GlobalInitialize_##propertyType(destination); \
555 } \
556 static void DesiredPropertyDeinitialize_##modelName##propertyName(void* destination) \
557 { \
558 GlobalDeinitialize_##propertyType(destination); \
559 } \
560 REFLECTED_DESIRED_PROPERTY(propertyType, propertyName, modelName, __VA_ARGS__) \
561
562#define CREATE_MODEL_ACTION(modelName, actionName, ...) \
563 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(modelName##actionName, 1); \
564 EXECUTE_COMMAND_RESULT actionName (modelName* device MU_FOR_EACH_2(DEFINE_FUNCTION_PARAMETER, __VA_ARGS__)); \
565 static EXECUTE_COMMAND_RESULT MU_C2(actionName, WRAPPER)(void* device, size_t ParameterCount, const AGENT_DATA_TYPE* values); \
566 /*for macro purposes, this array always has at least 1 element*/ \
567 /*Codes_SRS_SERIALIZER_99_043:[ It is valid for a method not to have any parameters.]*/ \
568 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 1); \
569 static const WRAPPER_ARGUMENT MU_C2(actionName, WRAPPERARGUMENTS)[MU_DIV2(MU_INC(MU_INC(MU_COUNT_ARG(__VA_ARGS__))))] = { MU_FOR_EACH_2_COUNTED(MAKE_WRAPPER_ARGUMENT, __VA_ARGS__) MU_IFCOMMA(MU_INC(MU_INC(MU_COUNT_ARG(__VA_ARGS__)))) {0} }; \
570 REFLECTED_ACTION(actionName, MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), MU_C2(actionName, WRAPPERARGUMENTS), MU_C2(actionName, WRAPPER), modelName) \
571 /*Codes_SRS_SERIALIZER_99_040:[ In addition to declaring the function, DECLARE_IOT_METHOD shall provide a definition for a wrapper that takes as parameters a size_t parameterCount and const AGENT_DATA_TYPE*.] */ \
572 /*Codes_SRS_SERIALIZER_99_041:[ This wrapper shall convert all the arguments to predefined types and then call the function written by the data provider developer.]*/ \
573 static EXECUTE_COMMAND_RESULT MU_C2(actionName, WRAPPER)(void* device, size_t ParameterCount, const AGENT_DATA_TYPE* values) \
574 { \
575 EXECUTE_COMMAND_RESULT result; \
576 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 2); \
577 /*Codes_SRS_SERIALIZER_99_045:[ If the number of passed parameters doesn't match the number of declared parameters, wrapper execution shall fail and return DATA_PROVIDER_INVALID_ARG;]*/ \
578 if(ParameterCount != MU_DIV2(MU_COUNT_ARG(__VA_ARGS__))) \
579 { \
580 result = EXECUTE_COMMAND_ERROR; \
581 } \
582 else \
583 { \
584 /*the below line takes care of initialized but not referenced parameter warning*/ \
585 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 3); \
586 MU_IF(MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), size_t iParameter = 0;, ) \
587 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 4); \
588 /*the below line takes care of an unused parameter when values is really never questioned*/ \
589 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 5); \
590 MU_FOR_EACH_2(DEFINE_LOCAL_PARAMETER, __VA_ARGS__) \
591 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 6); \
592 MU_IF(MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), , (void)values;) \
593 { \
594 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 7); \
595 } \
596 MU_FOR_EACH_2_KEEP_1(START_BUILD_LOCAL_PARAMETER, EXECUTE_COMMAND_ERROR, __VA_ARGS__) \
597 { \
598 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 8); \
599 } \
600 result = actionName((modelName*)device MU_FOR_EACH_2(PUSH_LOCAL_PARAMETER, __VA_ARGS__)); \
601 MU_FOR_EACH_2_REVERSE(END_BUILD_LOCAL_PARAMETER, __VA_ARGS__) \
602 } \
603 return result; \
604 }
605
606#define CREATE_MODEL_METHOD(modelName, methodName, ...) \
607 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(modelName##methodName, 1); \
608 METHODRETURN_HANDLE methodName (modelName* device MU_FOR_EACH_2(DEFINE_FUNCTION_PARAMETER, __VA_ARGS__)); \
609 static METHODRETURN_HANDLE MU_C2(methodName, WRAPPER)(void* device, size_t ParameterCount, const AGENT_DATA_TYPE* values); \
610 /*for macro purposes, this array always has at least 1 element*/ \
611 /*Codes_SRS_SERIALIZER_H_02_030: [ It is valid for a method function not to have any parameters. ]*/ \
612 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(methodName, 1); \
613 static const WRAPPER_ARGUMENT MU_C2(methodName, WRAPPERARGUMENTS)[MU_DIV2(MU_INC(MU_INC(MU_COUNT_ARG(__VA_ARGS__))))] = { MU_FOR_EACH_2_COUNTED(MAKE_WRAPPER_ARGUMENT, __VA_ARGS__) MU_IFCOMMA(MU_INC(MU_INC(MU_COUNT_ARG(__VA_ARGS__)))) {0} }; \
614 REFLECTED_METHOD(methodName, MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), MU_C2(methodName, WRAPPERARGUMENTS), MU_C2(methodName, WRAPPER), modelName) \
615 /*Codes_SRS_SERIALIZER_H_02_034: [ WITH_METHOD shall result in the declaration of a conversion function with the prototype METHODRETURN_HANDLE nameWRAPPER(size_t ParameterCount, const AGENT_DATA_TYPE* values)' ]*/ \
616 /*Codes_SRS_SERIALIZER_H_02_031: [ The function shall convert the input arguments to the types declared in the method parameter list and then call the user-defined method function. ]*/ \
617 static METHODRETURN_HANDLE MU_C2(methodName, WRAPPER)(void* device, size_t ParameterCount, const AGENT_DATA_TYPE* values) \
618 { \
619 METHODRETURN_HANDLE result; \
620 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(methodName, 2); \
621 /*Codes_SRS_SERIALIZER_H_02_032: [ If the number of arguments passed to the conversion function does not match the expected count, the function shall return DATAPROVIDER_INVALID_ARG. ]*/ \
622 if(ParameterCount != MU_DIV2(MU_COUNT_ARG(__VA_ARGS__))) \
623 { \
624 LogError("expected parameter count (%lu) does not match the actual parameter count (%lu)", (unsigned long)ParameterCount, (unsigned long)MU_COUNT_ARG(__VA_ARGS__)); \
625 result = NULL; \
626 } \
627 else \
628 { \
629 /*the below line takes care of initialized but not referenced parameter warning*/ \
630 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(methodName, 3); \
631 MU_IF(MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), size_t iParameter = 0;, ) \
632 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(methodName, 4); \
633 /*the below line takes care of an unused parameter when values is really never questioned*/ \
634 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(methodName, 5); \
635 MU_FOR_EACH_2(DEFINE_LOCAL_PARAMETER, __VA_ARGS__) \
636 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(methodName, 6); \
637 MU_IF(MU_DIV2(MU_COUNT_ARG(__VA_ARGS__)), , (void)values;) \
638 { \
639 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 7); \
640 } \
641 MU_FOR_EACH_2_KEEP_1(START_BUILD_LOCAL_PARAMETER, NULL,__VA_ARGS__) \
642 { \
643 DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(actionName, 8); \
644 } \
645 result = methodName((modelName*)device MU_FOR_EACH_2(PUSH_LOCAL_PARAMETER, __VA_ARGS__)); \
646 MU_FOR_EACH_2_REVERSE(END_BUILD_LOCAL_PARAMETER, __VA_ARGS__) \
647 } \
648 return result; \
649 }
650
651#define CREATE_AGENT_DATA_TYPE(type, name) \
652 result = (( result==AGENT_DATA_TYPES_OK) && (ToAGENT_DATA_TYPE_##type( &(members[iMember]), value.name) == AGENT_DATA_TYPES_OK))?AGENT_DATA_TYPES_OK:AGENT_DATA_TYPES_ERROR; \
653 iMember+= ((result==AGENT_DATA_TYPES_OK)?1:0);
654
655#define BUILD_DESTINATION_FIELD(type, name) \
656 if(result == AGENT_DATA_TYPES_OK) \
657 { \
658 size_t i; \
659 bool wasFieldConverted = false; \
660 for (i = 0; i < source->value.edmComplexType.nMembers; i++) \
661 { \
662 /*the name of the field of the complex type must match the name of the field of the structure (parameter name here)*/ \
663 if (strcmp(source->value.edmComplexType.fields[i].fieldName, MU_TOSTRING(name)) == 0) \
664 { /*Codes_SRS_SERIALIZER_99_017:[ These types can either be one of the types mentioned in WITH_DATA or it can be a type introduced by a previous DECLARE_STRUCT.]*/ \
665 wasFieldConverted = (MU_C2(FromAGENT_DATA_TYPE_, type)(source->value.edmComplexType.fields[i].value, &(destination->name)) == AGENT_DATA_TYPES_OK); \
666 break; \
667 } \
668 } \
669 result = (wasFieldConverted == true)? AGENT_DATA_TYPES_OK: AGENT_DATA_TYPES_INVALID_ARG; \
670 } \
671 else \
672 { \
673 /*fallthrough*/ \
674 }
675
676#define UNBUILD_DESTINATION_FIELD(value, type, name) \
677 MU_C2(destroyLocalParameter, type)(&(value->name));
678
679
680#define ADDRESS_MACRO(x) ,&x
681
682#define KEEP_FIRST_(X, ...) X
683#ifdef _MSC_VER
684#define KEEP_FIRST(X) KEEP_FIRST_ LPAREN X)
685#else
686#define KEEP_FIRST(X) KEEP_FIRST_(X)
687#endif
688
689#define PROMOTIONMAP_float double, double
690#define PROMOTIONMAP_int8_t int, int
691#define PROMOTIONMAP_uint8_t int, int
692#define PROMOTIONMAP_int16_t int, int
693#define PROMOTIONMAP__Bool int, int
694#define PROMOTIONMAP_bool int, int
695
696#define CASTMAP_float (float), (float)
697#define CASTMAP_int8_t (int8_t), (int8_t)
698#define CASTMAP_uint8_t (uint8_t), (uint8_t)
699#define CASTMAP_int16_t (int16_t), (int16_t)
700#define CASTMAP__Bool 0!=, 0!=
701#define CASTMAP_bool 0!=, 0!=
702
703#define EMPTY_TOKEN
704
705#define ANOTHERIF(x) MU_C2(ANOTHERIF,x)
706#define ANOTHERIF0(a,b) a
707#define ANOTHERIF1(a,b) b
708#define ANOTHERIF2(a,b) b
709#define ANOTHERIF3(a,b) b
710#define ANOTHERIF4(a,b) b
711#define ANOTHERIF5(a,b) b
712#define ANOTHERIF6(a,b) b
713#define ANOTHERIF7(a,b) b
714#define ANOTHERIF8(a,b) b
715#define ANOTHERIF9(a,b) b
716#define ANOTHERIF10(a,b) b
717#define ANOTHERIF11(a,b) b
718#define ANOTHERIF12(a,b) b
719
720#define MAP_PROMOTED_TYPE(X) ANOTHERIF(MU_DEC(MU_COUNT_ARG(PROMOTIONMAP_##X))) (X, KEEP_FIRST(PROMOTIONMAP_##X))
721#define MAP_CAST_TYPE(X) ANOTHERIF(MU_DEC(MU_COUNT_ARG(CASTMAP_##X))) (EMPTY_TOKEN, KEEP_FIRST(CASTMAP_##X) )
722
723#define MU_IFCOMMA(N) MU_C2(MU_IFCOMMA_, N)
724#define MU_IFCOMMA_0
725#define MU_IFCOMMA_2
726#define MU_IFCOMMA_4 ,
727#define MU_IFCOMMA_6 ,
728#define MU_IFCOMMA_8 ,
729#define MU_IFCOMMA_10 ,
730#define MU_IFCOMMA_12 ,
731#define MU_IFCOMMA_14 ,
732#define MU_IFCOMMA_16 ,
733#define MU_IFCOMMA_18 ,
734#define MU_IFCOMMA_20 ,
735#define MU_IFCOMMA_22 ,
736#define MU_IFCOMMA_24 ,
737#define MU_IFCOMMA_26 ,
738#define MU_IFCOMMA_28 ,
739#define MU_IFCOMMA_30 ,
740#define MU_IFCOMMA_32 ,
741#define MU_IFCOMMA_34 ,
742#define MU_IFCOMMA_36 ,
743#define MU_IFCOMMA_38 ,
744#define MU_IFCOMMA_40 ,
745#define MU_IFCOMMA_42 ,
746#define MU_IFCOMMA_44 ,
747#define MU_IFCOMMA_46 ,
748#define MU_IFCOMMA_48 ,
749#define MU_IFCOMMA_50 ,
750#define MU_IFCOMMA_52 ,
751#define MU_IFCOMMA_54 ,
752#define MU_IFCOMMA_56 ,
753#define MU_IFCOMMA_58 ,
754#define MU_IFCOMMA_60 ,
755#define MU_IFCOMMA_62 ,
756#define MU_IFCOMMA_64 ,
757#define MU_IFCOMMA_66 ,
758#define MU_IFCOMMA_68 ,
759#define MU_IFCOMMA_70 ,
760#define MU_IFCOMMA_72 ,
761#define MU_IFCOMMA_74 ,
762#define MU_IFCOMMA_76 ,
763#define MU_IFCOMMA_78 ,
764#define MU_IFCOMMA_80 ,
765#define MU_IFCOMMA_82 ,
766#define MU_IFCOMMA_84 ,
767#define MU_IFCOMMA_86 ,
768#define MU_IFCOMMA_88 ,
769#define MU_IFCOMMA_90 ,
770#define MU_IFCOMMA_92 ,
771#define MU_IFCOMMA_94 ,
772#define MU_IFCOMMA_96 ,
773#define MU_IFCOMMA_98 ,
774#define MU_IFCOMMA_100 ,
775#define MU_IFCOMMA_102 ,
776#define MU_IFCOMMA_104 ,
777#define MU_IFCOMMA_106 ,
778#define MU_IFCOMMA_108 ,
779#define MU_IFCOMMA_110 ,
780#define MU_IFCOMMA_112 ,
781#define MU_IFCOMMA_114 ,
782#define MU_IFCOMMA_116 ,
783#define MU_IFCOMMA_118 ,
784#define MU_IFCOMMA_120 ,
785#define MU_IFCOMMA_122 ,
786#define MU_IFCOMMA_124 ,
787#define MU_IFCOMMA_126 ,
788#define MU_IFCOMMA_128 ,
789
790#define DEFINE_LOCAL_PARAMETER(type, name) type MU_C2(name,_local); GlobalInitialize_##type(& MU_C2(name, _local));
791
792#define START_BUILD_LOCAL_PARAMETER(errorWhenItFails, type, name) \
793 if (MU_C2(FromAGENT_DATA_TYPE_, type)(&values[iParameter], &MU_C2(name, _local)) != AGENT_DATA_TYPES_OK) \
794 { \
795 /*Codes_SRS_SERIALIZER_99_046:[ If the types of the parameters do not match the declared types, DATAPROVIDER_INVALID_ARG shall be returned.]*/ \
796 result = errorWhenItFails; \
797 }\
798 else \
799 { \
800 iParameter++;
801
802#define END_BUILD_LOCAL_PARAMETER(type, name) \
803 (void)MU_C2(destroyLocalParameter, type)(&MU_C2(name, _local)); \
804 }
805
806/*The following constructs have been devised to work around the precompiler bug of Visual Studio 2005, version 14.00.50727.42*/
807/* The bug is explained in https://connect.microsoft.com/VisualStudio/feedback/details/278752/comma-missing-when-using-va-args */
808/*A short description is: preprocessor is mysteriously eating commas ','.
809In order to feed the appetite of the preprocessor, several constructs have
810been devised that can sustain a missing ',' while still compiling and while still doing nothing
811and while hopefully being eliminated from the code based on "doesn't do anything" so no code size penalty
812*/
813
814/*the reason why all these constructs work is:
815if two strings separated by a comma will lose the comma (myteriously) then they will become just one string:
816"a", "b" ------Preprocessor------> "a" "b" -----Compiler----> "ab"
817*/
818
819#define LOTS_OF_COMMA_TO_BE_EATEN /*there were witnesses where as many as THREE commas have been eaten!*/ \
820"0" "1", "2", "3", "4", "5", "6", "7", "8", "9"
821#define DEFINITION_THAT_CAN_SUSTAIN_A_COMMA_STEAL(name, instance) static const char* eatThese_COMMA_##name##instance[] = {LOTS_OF_COMMA_TO_BE_EATEN}
822
823#define PUSH_LOCAL_PARAMETER(type, name) , MU_C2(name, _local)
824#define DEFINE_FUNCTION_PARAMETER(type, name) , type name
825#define MAKE_WRAPPER_ARGUMENT(N, type, name) {MU_TOSTRING(type), MU_TOSTRING(name)} MU_IFCOMMA(N)
826
827/*Codes_SRS_SERIALIZER_99_019:[ Create_AGENT_DATA_TYPE_from_DOUBLE]*/
828/*Codes_SRS_SERIALIZER_99_004:[ The propertyType can be any of the following data types: double]*/
829static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, double)(AGENT_DATA_TYPE* dest, double source)
830{
831 return Create_AGENT_DATA_TYPE_from_DOUBLE(dest, source);
832}
833
834static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, double)(const AGENT_DATA_TYPE* agentData, double* dest)
835{
836 AGENT_DATA_TYPES_RESULT result;
837 if (agentData->type != EDM_DOUBLE_TYPE)
838 {
839 result = AGENT_DATA_TYPES_INVALID_ARG;
840 }
841 else
842 {
843 *dest = agentData->value.edmDouble.value;
844 result = AGENT_DATA_TYPES_OK;
845 }
846 return result;
847}
848
849static void MU_C2(GlobalInitialize_, double)(void* dest)
850{
851 *(double*)dest = 0.0;
852}
853
854static void MU_C2(GlobalDeinitialize_, double)(void* dest)
855{
856 (void)(dest);
857}
858
859/*Codes_SRS_SERIALIZER_99_021:[ Create_AGENT_DATA_TYPE_from_FLOAT]*/
860/*Codes_SRS_SERIALIZER_99_006:[ float]*/
861static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, float)(AGENT_DATA_TYPE* dest, float source)
862{
863 return Create_AGENT_DATA_TYPE_from_FLOAT(dest, source);
864}
865
866static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, float)(const AGENT_DATA_TYPE* agentData, float* dest)
867{
868 AGENT_DATA_TYPES_RESULT result;
869 if (agentData->type != EDM_SINGLE_TYPE)
870 {
871 result = AGENT_DATA_TYPES_INVALID_ARG;
872 }
873 else
874 {
875 *dest = agentData->value.edmSingle.value;
876 result = AGENT_DATA_TYPES_OK;
877 }
878 return result;
879}
880
881static void MU_C2(GlobalInitialize_, float)(void* dest)
882{
883 *(float*)dest = 0.0f;
884}
885
886static void MU_C2(GlobalDeinitialize_, float)(void* dest)
887{
888 (void)(dest);
889}
890
891
892/*Codes_SRS_SERIALIZER_99_020:[ Create_AGENT_DATA_TYPE_from_SINT32]*/
893/*Codes_SRS_SERIALIZER_99_005:[ int], */
894static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, int)(AGENT_DATA_TYPE* dest, int source)
895{
896 return Create_AGENT_DATA_TYPE_from_SINT32(dest, source);
897}
898
899static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, int)(const AGENT_DATA_TYPE* agentData, int* dest)
900{
901 AGENT_DATA_TYPES_RESULT result;
902 if (agentData->type != EDM_INT32_TYPE)
903 {
904 result = AGENT_DATA_TYPES_INVALID_ARG;
905 }
906 else
907 {
908 *dest = agentData->value.edmInt32.value;
909 result = AGENT_DATA_TYPES_OK;
910 }
911 return result;
912}
913
914static void MU_C2(GlobalInitialize_, int)(void* dest)
915{
916 *(int*)dest = 0;
917}
918
919static void MU_C2(GlobalDeinitialize_, int)(void* dest)
920{
921 (void)(dest);
922}
923
924/*Codes_SRS_SERIALIZER_99_022:[ Create_AGENT_DATA_TYPE_from_SINT64]*/
925/*Codes_SRS_SERIALIZER_99_007:[ long]*/
926static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, long)(AGENT_DATA_TYPE* dest, long source)
927{
928 return Create_AGENT_DATA_TYPE_from_SINT64(dest, source);
929}
930
931static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, long)(const AGENT_DATA_TYPE* agentData, long* dest)
932{
933 AGENT_DATA_TYPES_RESULT result;
934 if (agentData->type != EDM_INT64_TYPE)
935 {
936 result = AGENT_DATA_TYPES_INVALID_ARG;
937 }
938 else
939 {
940 *dest = (long)agentData->value.edmInt64.value;
941 result = AGENT_DATA_TYPES_OK;
942 }
943 return result;
944}
945
946static void MU_C2(GlobalInitialize_, long)(void* dest)
947{
948 *(long*)dest = 0;
949}
950
951static void MU_C2(GlobalDeinitialize_, long)(void* dest)
952{
953 (void)(dest);
954}
955
956
957/*Codes_SRS_SERIALIZER_99_023:[ Create_AGENT_DATA_TYPE_from_SINT8]*/
958/*Codes_SRS_SERIALIZER_99_008:[ int8_t]*/
959static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, int8_t)(AGENT_DATA_TYPE* dest, int8_t source)
960{
961 return Create_AGENT_DATA_TYPE_from_SINT8(dest, source);
962}
963
964static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, int8_t)(const AGENT_DATA_TYPE* agentData, int8_t* dest)
965{
966 AGENT_DATA_TYPES_RESULT result;
967 if (agentData->type != EDM_SBYTE_TYPE)
968 {
969 result = AGENT_DATA_TYPES_INVALID_ARG;
970 }
971 else
972 {
973 *dest = agentData->value.edmSbyte.value;
974 result = AGENT_DATA_TYPES_OK;
975 }
976 return result;
977}
978
979static void MU_C2(GlobalInitialize_, int8_t)(void* dest)
980{
981 *(int8_t*)dest = 0;
982}
983
984static void MU_C2(GlobalDeinitialize_, int8_t)(void* dest)
985{
986 (void)(dest);
987}
988
989/*Codes_SRS_SERIALIZER_99_024:[ Create_AGENT_DATA_TYPE_from_UINT8]*/
990/*Codes_SRS_SERIALIZER_99_009:[ uint8_t]*/
991static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, uint8_t)(AGENT_DATA_TYPE* dest, uint8_t source)
992{
993 return Create_AGENT_DATA_TYPE_from_UINT8(dest, source);
994}
995
996static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, uint8_t)(const AGENT_DATA_TYPE* agentData, uint8_t* dest)
997{
998 AGENT_DATA_TYPES_RESULT result;
999 if (agentData->type != EDM_BYTE_TYPE)
1000 {
1001 result = AGENT_DATA_TYPES_INVALID_ARG;
1002 }
1003 else
1004 {
1005 *dest = agentData->value.edmByte.value;
1006 result = AGENT_DATA_TYPES_OK;
1007 }
1008 return result;
1009}
1010
1011static void MU_C2(GlobalInitialize_, uint8_t)(void* dest)
1012{
1013 *(uint8_t*)dest = 0;
1014}
1015
1016static void MU_C2(GlobalDeinitialize_, uint8_t)(void* dest)
1017{
1018 (void)(dest);
1019}
1020
1021
1022/*Codes_SRS_SERIALIZER_99_025:[ Create_AGENT_DATA_TYPE_from_SINT16]*/
1023/*Codes_SRS_SERIALIZER_99_010:[ int16_t]*/
1024static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, int16_t)(AGENT_DATA_TYPE* dest, int16_t source)
1025{
1026 return Create_AGENT_DATA_TYPE_from_SINT16(dest, source);
1027}
1028
1029static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, int16_t)(const AGENT_DATA_TYPE* agentData, int16_t* dest)
1030{
1031 AGENT_DATA_TYPES_RESULT result;
1032 if (agentData->type != EDM_INT16_TYPE)
1033 {
1034 result = AGENT_DATA_TYPES_INVALID_ARG;
1035 }
1036 else
1037 {
1038 *dest = agentData->value.edmInt16.value;
1039 result = AGENT_DATA_TYPES_OK;
1040 }
1041 return result;
1042}
1043
1044static void MU_C2(GlobalInitialize_, int16_t)(void* dest)
1045{
1046 *(int16_t*)dest = 0;
1047}
1048
1049static void MU_C2(GlobalDeinitialize_, int16_t)(void* dest)
1050{
1051 (void)(dest);
1052}
1053
1054/*Codes_SRS_SERIALIZER_99_026:[ Create_AGENT_DATA_TYPE_from_SINT32]*/
1055/*Codes_SRS_SERIALIZER_99_011:[ int32_t]*/
1056static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, int32_t)(AGENT_DATA_TYPE* dest, int32_t source)
1057{
1058 return Create_AGENT_DATA_TYPE_from_SINT32(dest, source);
1059}
1060
1061static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, int32_t)(const AGENT_DATA_TYPE* agentData, int32_t* dest)
1062{
1063 AGENT_DATA_TYPES_RESULT result;
1064 if (agentData->type != EDM_INT32_TYPE)
1065 {
1066 result = AGENT_DATA_TYPES_INVALID_ARG;
1067 }
1068 else
1069 {
1070 *dest = agentData->value.edmInt32.value;
1071 result = AGENT_DATA_TYPES_OK;
1072 }
1073 return result;
1074}
1075
1076static void MU_C2(GlobalInitialize_, int32_t)(void* dest)
1077{
1078 *(int32_t*)dest = 0;
1079}
1080
1081static void MU_C2(GlobalDeinitialize_, int32_t)(void* dest)
1082{
1083 (void)(dest);
1084}
1085
1086/*Codes_SRS_SERIALIZER_99_027:[ Create_AGENT_DATA_TYPE_from_SINT64]*/
1087/*Codes_SRS_SERIALIZER_99_012:[ int64_t]*/
1088static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, int64_t)(AGENT_DATA_TYPE* dest, int64_t source)
1089{
1090 return Create_AGENT_DATA_TYPE_from_SINT64(dest, source);
1091}
1092
1093static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, int64_t)(const AGENT_DATA_TYPE* agentData, int64_t* dest)
1094{
1095 AGENT_DATA_TYPES_RESULT result;
1096 if (agentData->type != EDM_INT64_TYPE)
1097 {
1098 result = AGENT_DATA_TYPES_INVALID_ARG;
1099 }
1100 else
1101 {
1102 *dest = agentData->value.edmInt64.value;
1103 result = AGENT_DATA_TYPES_OK;
1104 }
1105 return result;
1106}
1107
1108static void MU_C2(GlobalInitialize_, int64_t)(void* dest)
1109{
1110 *(int64_t*)dest = 0;
1111}
1112
1113static void MU_C2(GlobalDeinitialize_, int64_t)(void* dest)
1114{
1115 (void)(dest);
1116}
1117
1118/*Codes_SRS_SERIALIZER_99_013:[ bool]*/
1119static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, bool)(AGENT_DATA_TYPE* dest, bool source)
1120{
1121 return Create_EDM_BOOLEAN_from_int(dest, source == true);
1122}
1123
1124static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, bool)(const AGENT_DATA_TYPE* agentData, bool* dest)
1125{
1126 AGENT_DATA_TYPES_RESULT result;
1127 if (agentData->type != EDM_BOOLEAN_TYPE)
1128 {
1129 result = AGENT_DATA_TYPES_INVALID_ARG;
1130 }
1131 else
1132 {
1133 *dest = (agentData->value.edmBoolean.value == EDM_TRUE) ? true : false;
1134 result = AGENT_DATA_TYPES_OK;
1135 }
1136 return result;
1137}
1138
1139static void MU_C2(GlobalInitialize_, bool)(void* dest)
1140{
1141 *(bool*)dest = false;
1142}
1143
1144static void MU_C2(GlobalDeinitialize_, bool)(void* dest)
1145{
1146 (void)(dest);
1147}
1148
1149/*Codes_SRS_SERIALIZER_99_014:[ ascii_char_ptr]*/
1150static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, ascii_char_ptr)(AGENT_DATA_TYPE* dest, ascii_char_ptr source)
1151{
1152 return Create_AGENT_DATA_TYPE_from_charz(dest, source);
1153}
1154
1155static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, ascii_char_ptr)(const AGENT_DATA_TYPE* agentData, ascii_char_ptr* dest)
1156{
1157 AGENT_DATA_TYPES_RESULT result;
1158 if (agentData->type != EDM_STRING_TYPE)
1159 {
1160 result = AGENT_DATA_TYPES_INVALID_ARG;
1161 }
1162 else
1163 {
1164 if (*dest != NULL)
1165 {
1166 free(*dest);
1167 *dest = NULL;
1168 }
1169
1170 if (mallocAndStrcpy_s(dest, agentData->value.edmString.chars) != 0)
1171 {
1172 LogError("failure in mallocAndStrcpy_s");
1173 result = AGENT_DATA_TYPES_ERROR;
1174 }
1175 else
1176 {
1177 result = AGENT_DATA_TYPES_OK;
1178 }
1179
1180 }
1181 return result;
1182}
1183
1184static void MU_C2(GlobalInitialize_, ascii_char_ptr)(void* dest)
1185{
1186 *(ascii_char_ptr*)dest = NULL;
1187}
1188
1189static void MU_C2(GlobalDeinitialize_, ascii_char_ptr)(void* dest)
1190{
1191 if (*(ascii_char_ptr*)dest != NULL)
1192 {
1193 free(*(ascii_char_ptr*)dest);
1194 }
1195}
1196
1197static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, ascii_char_ptr_no_quotes)(AGENT_DATA_TYPE* dest, ascii_char_ptr_no_quotes source)
1198{
1199 return Create_AGENT_DATA_TYPE_from_charz_no_quotes(dest, source);
1200}
1201
1202static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, ascii_char_ptr_no_quotes)(const AGENT_DATA_TYPE* agentData, ascii_char_ptr_no_quotes* dest)
1203{
1204 AGENT_DATA_TYPES_RESULT result;
1205 if (agentData->type != EDM_STRING_NO_QUOTES_TYPE)
1206 {
1207 result = AGENT_DATA_TYPES_INVALID_ARG;
1208 }
1209 else
1210 {
1211 if (*dest != NULL)
1212 {
1213 free(*dest);
1214 *dest = NULL;
1215 }
1216
1217 if (mallocAndStrcpy_s(dest, agentData->value.edmStringNoQuotes.chars) != 0)
1218 {
1219 LogError("failure in mallocAndStrcpy_s");
1220 result = AGENT_DATA_TYPES_ERROR;
1221 }
1222 else
1223 {
1224 result = AGENT_DATA_TYPES_OK;
1225 }
1226 }
1227 return result;
1228}
1229
1230static void MU_C2(GlobalInitialize_, ascii_char_ptr_no_quotes)(void* dest)
1231{
1232 *(ascii_char_ptr_no_quotes*)dest = NULL;
1233}
1234
1235static void MU_C2(GlobalDeinitialize_, ascii_char_ptr_no_quotes)(void* dest)
1236{
1237 if (*(ascii_char_ptr_no_quotes*)dest != NULL)
1238 {
1239 free(*(ascii_char_ptr_no_quotes*)dest);
1240 }
1241}
1242
1243/*Codes_SRS_SERIALIZER_99_051:[ EDM_DATE_TIME_OFFSET*/
1244/*Codes_SRS_SERIALIZER_99_053:[Create_AGENT_DATA_TYPE_from_EDM_DATE_TIME_OFFSET]*/
1245static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, EDM_DATE_TIME_OFFSET)(AGENT_DATA_TYPE* dest, EDM_DATE_TIME_OFFSET source)
1246{
1247 return Create_AGENT_DATA_TYPE_from_EDM_DATE_TIME_OFFSET(dest, source);
1248}
1249
1250static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, EDM_DATE_TIME_OFFSET)(const AGENT_DATA_TYPE* agentData, EDM_DATE_TIME_OFFSET* dest)
1251{
1252 AGENT_DATA_TYPES_RESULT result;
1253 if (agentData->type != EDM_DATE_TIME_OFFSET_TYPE)
1254 {
1255 result = AGENT_DATA_TYPES_INVALID_ARG;
1256 }
1257 else
1258 {
1259 *dest = agentData->value.edmDateTimeOffset;
1260 result = AGENT_DATA_TYPES_OK;
1261 }
1262 return result;
1263}
1264
1265static void MU_C2(GlobalInitialize_, EDM_DATE_TIME_OFFSET)(void* dest)
1266{
1267 memset(dest, 0, sizeof(EDM_DATE_TIME_OFFSET));
1268}
1269
1270static void MU_C2(GlobalDeinitialize_, EDM_DATE_TIME_OFFSET)(void* dest)
1271{
1272 (void)(dest);
1273}
1274
1275/*Codes_SRS_SERIALIZER_99_072:[ EDM_GUID]*/
1276/*Codes_SRS_SERIALIZER_99_073:[ Create_AGENT_DATA_TYPE_from_EDM_GUID]*/
1277static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, EDM_GUID)(AGENT_DATA_TYPE* dest, EDM_GUID guid)
1278{
1279 return Create_AGENT_DATA_TYPE_from_EDM_GUID(dest, guid);
1280}
1281
1282static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, EDM_GUID)(const AGENT_DATA_TYPE* agentData, EDM_GUID* dest)
1283{
1284 AGENT_DATA_TYPES_RESULT result;
1285 if (agentData->type != EDM_GUID_TYPE)
1286 {
1287 result = AGENT_DATA_TYPES_INVALID_ARG;
1288 }
1289 else
1290 {
1291 (void)memcpy(dest->GUID, agentData->value.edmGuid.GUID, 16);
1292 result = AGENT_DATA_TYPES_OK;
1293 }
1294 return result;
1295}
1296
1297static void MU_C2(GlobalInitialize_, EDM_GUID)(void* dest)
1298{
1299 memset(dest, 0, sizeof(EDM_GUID));
1300}
1301
1302static void MU_C2(GlobalDeinitialize_, EDM_GUID)(void* dest)
1303{
1304 (void)(dest);
1305}
1306
1307
1308/*Codes_SRS_SERIALIZER_99_074:[ EDM_BINARY]*/
1309/*Codes_SRS_SERIALIZER_99_075:[ Create_AGENT_DATA_TYPE_from_EDM_BINARY]*/
1310static AGENT_DATA_TYPES_RESULT MU_C2(ToAGENT_DATA_TYPE_, EDM_BINARY)(AGENT_DATA_TYPE* dest, EDM_BINARY edmBinary)
1311{
1312 return Create_AGENT_DATA_TYPE_from_EDM_BINARY(dest, edmBinary);
1313}
1314
1315static AGENT_DATA_TYPES_RESULT MU_C2(FromAGENT_DATA_TYPE_, EDM_BINARY)(const AGENT_DATA_TYPE* agentData, EDM_BINARY* dest)
1316{
1317 AGENT_DATA_TYPES_RESULT result;
1318 if (agentData->type != EDM_BINARY_TYPE)
1319 {
1320 result = AGENT_DATA_TYPES_INVALID_ARG;
1321 }
1322 else
1323 {
1324 if ((dest->data = (unsigned char *)malloc(agentData->value.edmBinary.size)) == NULL) /*cast because this get included in a C++ file.*/
1325 {
1326 result = AGENT_DATA_TYPES_ERROR;
1327 }
1328 else
1329 {
1330 (void)memcpy(dest->data, agentData->value.edmBinary.data, agentData->value.edmBinary.size);
1331 dest->size = agentData->value.edmBinary.size;
1332 result = AGENT_DATA_TYPES_OK;
1333 }
1334 }
1335 return result;
1336}
1337
1338static void MU_C2(GlobalInitialize_, EDM_BINARY)(void* dest)
1339{
1340 ((EDM_BINARY*)dest)->data = NULL;
1341 ((EDM_BINARY*)dest)->size = 0;
1342}
1343
1344static void MU_C2(GlobalDeinitialize_, EDM_BINARY)(void* dest)
1345{
1346 if ((((EDM_BINARY*)dest)->data) != NULL)
1347 {
1348 free(((EDM_BINARY*)dest)->data);
1349 }
1350}
1351
1352static void MU_C2(destroyLocalParameter, EDM_BINARY)(EDM_BINARY* value)
1353{
1354 if (value != NULL)
1355 {
1356 free(value->data);
1357 value->data = NULL;
1358 value->size = 0;
1359 }
1360}
1361
1362static void MU_C2(destroyLocalParameter, EDM_BOOLEAN)(EDM_BOOLEAN* value)
1363{
1364 (void)value;
1365}
1366
1367static void MU_C2(destroyLocalParameter, EDM_BYTE)(EDM_BYTE* value)
1368{
1369 (void)value;
1370}
1371
1372static void MU_C2(destroyLocalParameter, EDM_DATE)(EDM_DATE* value)
1373{
1374 (void)value;
1375}
1376
1377static void MU_C2(destroyLocalParameter, EDM_DATE_TIME_OFFSET)(EDM_DATE_TIME_OFFSET* value)
1378{
1379 (void)value;
1380}
1381
1382static void MU_C2(destroyLocalParameter, EDM_DECIMAL)(EDM_DECIMAL* value)
1383{
1384 if (value != NULL)
1385 {
1386 STRING_delete(value->value);
1387 value->value = NULL;
1388 }
1389}
1390
1391static void MU_C2(destroyLocalParameter, EDM_DOUBLE)(EDM_DOUBLE* value)
1392{
1393 (void)value;
1394}
1395
1396static void MU_C2(destroyLocalParameter, EDM_DURATION)(EDM_DURATION* value)
1397{
1398 if (value != NULL)
1399 {
1400 free(value->digits);
1401 value->digits = NULL;
1402 value->nDigits = 0;
1403 }
1404}
1405
1406static void MU_C2(destroyLocalParameter, EDM_GUID)(EDM_GUID* value)
1407{
1408 (void)value;
1409}
1410
1411static void MU_C2(destroyLocalParameter, EDM_INT16)(EDM_INT16* value)
1412{
1413 (void)value;
1414}
1415
1416static void MU_C2(destroyLocalParameter, EDM_INT32)(EDM_INT32* value)
1417{
1418 (void)value;
1419}
1420
1421static void MU_C2(destroyLocalParameter, EDM_INT64)(EDM_INT64* value)
1422{
1423 (void)value;
1424}
1425
1426static void MU_C2(destroyLocalParameter, EDM_SBYTE)(EDM_SBYTE* value)
1427{
1428 (void)value;
1429}
1430
1431static void MU_C2(destroyLocalParameter, EDM_SINGLE)(EDM_SINGLE* value)
1432{
1433 (void)value;
1434}
1435
1436static void MU_C2(destroyLocalParameter, EDM_STRING)(EDM_STRING* value)
1437{
1438 (void)value;
1439}
1440
1441
1442static void MU_C2(destroyLocalParameter, EDM_TIME_OF_DAY)(EDM_TIME_OF_DAY* value)
1443{
1444 (void)value;
1445}
1446
1447static void MU_C2(destroyLocalParameter, int)(int* value)
1448{
1449 (void)value;
1450}
1451
1452static void MU_C2(destroyLocalParameter, float)(float* value)
1453{
1454 (void)value;
1455}
1456
1457static void MU_C2(destroyLocalParameter, double)(double* value)
1458{
1459 (void)value;
1460}
1461
1462static void MU_C2(destroyLocalParameter, long)(long* value)
1463{
1464 (void)value;
1465}
1466
1467static void MU_C2(destroyLocalParameter, int8_t)(int8_t* value)
1468{
1469 (void)value;
1470}
1471
1472static void MU_C2(destroyLocalParameter, uint8_t)(uint8_t* value)
1473{
1474 (void)value;
1475}
1476
1477static void MU_C2(destroyLocalParameter, int16_t)(int16_t* value)
1478{
1479 (void)value;
1480}
1481
1482static void MU_C2(destroyLocalParameter, int32_t)(int32_t* value)
1483{
1484 (void)value;
1485}
1486
1487static void MU_C2(destroyLocalParameter, int64_t)(int64_t* value)
1488{
1489 (void)value;
1490}
1491
1492static void MU_C2(destroyLocalParameter, bool)(bool* value)
1493{
1494 (void)value;
1495}
1496
1497static void MU_C2(destroyLocalParameter, ascii_char_ptr)(ascii_char_ptr* value)
1498{
1499 if (value != NULL)
1500 {
1501 free(*value);
1502 }
1503
1504}
1505
1506static void MU_C2(destroyLocalParameter, ascii_char_ptr_no_quotes)(ascii_char_ptr_no_quotes* value)
1507{
1508 if (value != NULL)
1509 {
1510 free(*value);
1511 }
1512}
1513
1514#ifdef __cplusplus
1515 }
1516#endif
1517
1518#endif /*SERIALIZER_H*/
1519
1520
Note: See TracBrowser for help on using the repository browser.