| /******************************************************************************* |
| * Copyright (C) 2004-2006 Intel Corp. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * - Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * - Neither the name of Intel Corp. nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| *******************************************************************************/ |
| |
| /** |
| * @author Anas Nashif |
| * @author Eugene Yarmosh |
| */ |
| |
| /** |
| * @defgroup XMLSerializer XML Serializer |
| * @brief Serializer and Deserializer Functions and Macros |
| * |
| * @{ |
| */ |
| |
| #ifndef WS_XML_SERIALIZER_H |
| #define WS_XML_SERIALIZER_H |
| |
| #include "wsman-types.h" |
| #include "wsman-names.h" |
| #include "u/libu.h" |
| |
| // Errors |
| #define WS_ERR_INSUFFICIENT_RESOURCES (-1) |
| #define WS_ERR_INVALID_PARAMETER (-2) |
| #define WS_ERR_XML_PARSING (-3) |
| #define WS_ERR_XML_NODE_NOT_FOUND (-4) |
| #define WS_ERR_NOT_IMPLEMENTED (-5) |
| |
| |
| typedef void* XML_TYPE_PTR; |
| |
| typedef struct __XmlSerialiseDynamicSizeData |
| { |
| unsigned int count; |
| XML_TYPE_PTR data; |
| } XmlSerialiseDynamicSizeData; |
| |
| #ifdef WIN32 |
| typedef char XML_TYPE_INT8; |
| typedef unsigned char XML_TYPE_UINT8; |
| typedef short XML_TYPE_INT16; |
| typedef unsigned short XML_TYPE_UINT16; |
| typedef long XML_TYPE_INT32; |
| typedef unsigned long XML_TYPE_UINT32; |
| typedef long long XML_TYPE_INT64; |
| typedef unsigned long long XML_TYPE_UINT64; |
| typedef int XML_TYPE_BOOL; |
| typedef char XML_TYPE_CHAR; |
| typedef float XML_TYPE_REAL32; |
| typedef double XML_TYPE_REAL64; |
| #define PTRTOINT unsigned long long |
| #else |
| #include <sys/types.h> |
| #if defined (__SVR4) && defined (__sun) |
| typedef uchar_t XML_TYPE_UINT8; |
| typedef ushort_t XML_TYPE_UINT16; |
| typedef uint_t XML_TYPE_UINT32; |
| typedef u_longlong_t XML_TYPE_UINT64; |
| typedef char XML_TYPE_INT8; |
| typedef short XML_TYPE_INT16; |
| typedef int XML_TYPE_INT32; |
| typedef long long XML_TYPE_INT64; |
| typedef float XML_TYPE_REAL32; |
| typedef double XML_TYPE_REAL64; |
| |
| typedef int XML_TYPE_BOOL; |
| typedef char XML_TYPE_CHAR; |
| #define PTRTOINT int |
| |
| #else |
| typedef u_int8_t XML_TYPE_UINT8; |
| typedef u_int16_t XML_TYPE_UINT16; |
| typedef u_int32_t XML_TYPE_UINT32; |
| typedef u_int64_t XML_TYPE_UINT64; |
| typedef int8_t XML_TYPE_INT8; |
| typedef int16_t XML_TYPE_INT16; |
| typedef int32_t XML_TYPE_INT32; |
| typedef int64_t XML_TYPE_INT64; |
| typedef float XML_TYPE_REAL32; |
| typedef double XML_TYPE_REAL64; |
| |
| typedef int XML_TYPE_BOOL; |
| typedef char XML_TYPE_CHAR; |
| #define PTRTOINT intptr_t |
| #endif |
| #endif |
| typedef struct { |
| struct tm tm; |
| int tz_min; // timezone GMT shift in minutes |
| } XML_DATETIME; |
| typedef char* XML_TYPE_STR; |
| typedef XmlSerialiseDynamicSizeData XML_TYPE_DYN_ARRAY; |
| struct _XML_NODE_ATTR; |
| struct _XML_NODE_ATTR { |
| struct _XML_NODE_ATTR *next; |
| char *ns; |
| char *name; |
| char *value; |
| }; |
| typedef struct _XML_NODE_ATTR XML_NODE_ATTR; |
| |
| #define SER_ENUMERATOR_PREFIX "_XmlSerializeEnum" |
| |
| |
| |
| |
| /** |
| * Count can be 1 for single elementd; > 1 for fixed size array; |
| * 0 for dynamic array. |
| */ |
| |
| |
| |
| struct __XmlSerializationData; |
| typedef int (*XmlSerializationProc)(struct __XmlSerializationData* data); |
| |
| struct __XmlSerializerInfo |
| { |
| const char *ns; |
| const char* name; |
| unsigned int mincount; /**< Minimal Count */ |
| unsigned int count; /**< Maximal Count */ |
| unsigned int size; /**< size of serialized/deserialized element */ |
| unsigned int flags; /**< flags */ |
| XmlSerializationProc proc; /**< Serialization Processor */ |
| XML_TYPE_PTR extData; /**< External Data */ |
| }; |
| typedef struct __XmlSerializerInfo XmlSerializerInfo; |
| |
| struct __WsSerializerContext |
| { |
| pthread_mutex_t lock; |
| list_t *WsSerializerAllocList; |
| }; |
| |
| typedef struct __WsSerializerContext *WsSerializerContextH; |
| |
| #define SER_IN 0x8000 |
| #define SER_OUT 0x4000 |
| #define SER_SKIP 0x2000 |
| #define SER_HEAD 0x1000 |
| #define SER_ATTRS 0x0800 |
| |
| #define XML_NUM_OCCURS(x) (x)->count |
| #define XML_MAX_OCCURS(x) (x)->count |
| #define XML_MIN_OCCURS(x) (x)->mincount |
| #define XML_IS_SKIP(x) ((x)->flags & SER_SKIP) |
| #define XML_IS_IN(x) ((x)->flags & SER_IN) |
| #define XML_IS_OUT(x) ((x)->flags & SER_OUT) |
| #define XML_IS_HEAD(x) ((x)->flags & SER_HEAD) |
| #define XML_IS_ATTRS(x) ((x)->flags & SER_ATTRS) |
| |
| |
| #define SER_NULL {NULL, NULL, 0, 0, 0, 0, NULL, NULL} |
| |
| /* Serializer Info base defines with min/max */ |
| |
| #define SER_NS_CNT_UINT8_FLAGS(ns, n, min, max, flags) \ |
| {(ns), (n), (min), (max), sizeof (XML_TYPE_UINT8), \ |
| flags, do_serialize_uint8, NULL \ |
| } |
| #define SER_NS_CNT_UINT16_FLAGS(ns, n, min, max, flags) \ |
| {(ns), (n), (min), (max), sizeof (XML_TYPE_UINT16), \ |
| flags, do_serialize_uint16, NULL \ |
| } |
| #define SER_NS_CNT_UINT32_FLAGS(ns, n, min, max, flags) \ |
| {(ns), (n), (min), (max), sizeof (XML_TYPE_UINT32), \ |
| flags, do_serialize_uint32, NULL \ |
| } |
| #define SER_NS_CNT_UINT64_FLAGS(ns, n, min, max, flags) \ |
| {(ns), (n), (min), (max), sizeof (XML_TYPE_UINT64), \ |
| flags, do_serialize_uint64, NULL \ |
| } |
| |
| #define SER_NS_CNT_BOOL_FLAGS(ns, n, min, max, flags) \ |
| {(ns), (n), (min), (max), sizeof (XML_TYPE_BOOL), \ |
| flags, do_serialize_bool, NULL \ |
| } |
| #define SER_NS_CNT_STR_FLAGS(ns, n, min, max, flags) \ |
| {(ns), (n), (min), (max), sizeof (XML_TYPE_STR), \ |
| flags, do_serialize_string, NULL \ |
| } |
| #define SER_NS_CNT_STRUCT_FLAGS(ns, n, min, max, flags, t) \ |
| {(ns), (n), (min), (max), sizeof (t), flags, \ |
| do_serialize_struct, t##_TypeItems \ |
| } |
| |
| // Serializer Info base defines |
| |
| #define SER_NS_INT8_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_INT8), \ |
| flags, do_serialize_int8, NULL \ |
| } |
| #define SER_NS_UINT8_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_UINT8), \ |
| flags, do_serialize_uint8, NULL \ |
| } |
| #define SER_NS_INT16_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_INT16), \ |
| flags, do_serialize_int16, NULL \ |
| } |
| #define SER_NS_UINT16_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_UINT16), \ |
| flags, do_serialize_uint16, NULL \ |
| } |
| #define SER_NS_INT32_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_INT32), \ |
| flags, do_serialize_int32, NULL \ |
| } |
| #define SER_NS_UINT32_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_UINT32), \ |
| flags, do_serialize_uint32, NULL \ |
| } |
| #define SER_NS_INT64_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_INT64), \ |
| flags, do_serialize_int64, NULL \ |
| } |
| #define SER_NS_UINT64_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_UINT64), \ |
| flags, do_serialize_uint64, NULL \ |
| } |
| #define SER_NS_REAL32_FLAGS(ns, n, x, flags)\ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_REAL32), \ |
| flags, do_serialize_real, NULL \ |
| } |
| #define SER_NS_REAL64_FLAGS(ns, n, x, flags)\ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_REAL64), \ |
| flags, do_serialize_real, NULL \ |
| } |
| #define SER_NS_BOOL_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_BOOL), \ |
| flags, do_serialize_bool, NULL \ |
| } |
| #define SER_NS_STR_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (XML_TYPE_STR), \ |
| flags, do_serialize_string, NULL \ |
| } |
| #define SER_NS_STRUCT_FLAGS(ns, n, x, flags, t) \ |
| {(ns), (n), (x), (x), sizeof (t), flags, \ |
| do_serialize_struct, t##_TypeItems \ |
| } |
| |
| #define SER_NS_DYN_ARRAY_FLAGS(ns, n, min, max, flags, t)\ |
| {(ns), (n), (min), (max), sizeof (XmlSerialiseDynamicSizeData), flags, \ |
| do_serialize_dyn_size_array, t##_TypeInfo \ |
| } |
| |
| // nodes with attributes |
| #define SER_ATTR_NS_INT8_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_INT8 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_int8, NULL \ |
| } |
| #define SER_ATTR_NS_UINT8_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_UINT8 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_uint8, NULL \ |
| } |
| #define SER_ATTR_NS_INT16_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_INT16 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_int16, NULL \ |
| } |
| #define SER_ATTR_NS_UINT16_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_UINT16 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_uint16, NULL \ |
| } |
| #define SER_ATTR_NS_INT32_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_INT32 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_int32, NULL \ |
| } |
| #define SER_ATTR_NS_UINT32_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_UINT32 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_uint32, NULL \ |
| } |
| #define SER_ATTR_NS_INT64_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_INT64 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_int64, NULL \ |
| } |
| #define SER_ATTR_NS_UINT64_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_UINT64 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_uint64, NULL \ |
| } |
| #define SER_ATTR_NS_REAL32_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_UINT32 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_real32, NULL \ |
| } |
| #define SER_ATTR_NS_REAL64_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_REAL64 s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_real64, NULL \ |
| } |
| #define SER_ATTR_NS_BOOL_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_BOOL s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_bool, NULL \ |
| } |
| #define SER_ATTR_NS_STR_FLAGS(ns, n, x, flags) \ |
| {(ns), (n), (x), (x), sizeof (struct {XML_TYPE_STR s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_string, NULL \ |
| } |
| #define SER_ATTR_NS_STRUCT_FLAGS(ns, n, x, flags, t) \ |
| {(ns), (n), (x), (x), sizeof (struct {t s; XML_NODE_ATTR *a;}), \ |
| flags | SER_ATTRS, do_serialize_struct, t##_TypeItems \ |
| } |
| |
| |
| // No namespace defines |
| #define SER_INT8_FLAGS(n, x, flags) SER_NS_INT8_FLAGS(NULL, n, x, flags) |
| #define SER_UINT8_FLAGS(n, x, flags) SER_NS_UINT8_FLAGS(NULL, n, x, flags) |
| #define SER_INT16_FLAGS(n, x, flags) SER_NS_INT16_FLAGS(NULL, n, x, flags) |
| #define SER_UINT16_FLAGS(n, x, flags) SER_NS_UINT16_FLAGS(NULL, n, x, flags) |
| #define SER_INT32_FLAGS(n, x, flags) SER_NS_INT32_FLAGS(NULL, n, x, flags) |
| #define SER_UINT32_FLAGS(n, x, flags) SER_NS_UINT32_FLAGS(NULL, n, x, flags) |
| #define SER_INT64_FLAGS(n, x, flags) SER_NS_INT64_FLAGS(NULL, n, x, flags) |
| #define SER_UINT64_FLAGS(n, x, flags) SER_NS_UINT64_FLAGS(NULL, n, x, flags) |
| #define SER_REAL32_FLAGS(n, x, flags) SER_NS_REAL32_FLAGS(NULL, n, x, flags) |
| #define SER_REAL64_FLAGS(n, x, flags) SER_NS_REAL64_FLAGS(NULL, n, x, flags) |
| #define SER_BOOL_FLAGS(n, x, flags) SER_NS_BOOL_FLAGS(NULL, n, x, flags) |
| #define SER_STR_FLAGS(n, x, flags) SER_NS_STR_FLAGS(NULL, n, x, flags) |
| #define SER_STRUCT_FLAGS(n, x, flags, t) \ |
| SER_NS_STRUCT_FLAGS(NULL, n, x, flags, t) |
| #define SER_DYN_ARRAY_FLAGS(n, min, max, flags, t) \ |
| SER_NS_DYN_ARRAY_FLAGS(NULL, n, min, max, flags, t) |
| |
| |
| // Serialization Info for different types |
| #define SER_INT8(n, x) SER_INT8_FLAGS(n, x, 0) |
| #define SER_UINT8(n, x) SER_UINT8_FLAGS(n, x, 0) |
| #define SER_INT16(n, x) SER_INT16_FLAGS(n, x, 0) |
| #define SER_UINT16(n, x) SER_UINT16_FLAGS(n, x, 0) |
| #define SER_INT32(n, x) SER_INT32_FLAGS(n, x, 0) |
| #define SER_UINT32(n, x) SER_UINT32_FLAGS(n, x, 0) |
| #define SER_INT64(n, x) SER_INT64_FLAGS(n, x, 0) |
| #define SER_UINT64(n, x) SER_UINT64_FLAGS(n, x, 0) |
| #define SER_REAL32(n, x) SER_REAL32_FLAGS(n, x, 0) |
| #define SER_REAL64(n, x) SER_REAL64_FLAGS(n, x, 0) |
| #define SER_BOOL(n, x) SER_BOOL_FLAGS(n, x, 0) |
| #define SER_STR(n, x) SER_STR_FLAGS(n, x, 0) |
| #define SER_STRUCT(n, x, t) SER_STRUCT_FLAGS(n, x, 0, t) |
| #define SER_DYN_ARRAY(n, mn, mx, t) SER_DYN_ARRAY_FLAGS(n, mn, mx, 0, t) |
| #define SER_NS_UINT8(ns, n, x) SER_NS_UINT8_FLAGS(ns, n, x, 0) |
| #define SER_NS_UINT16(ns, n, x) SER_NS_UINT16_FLAGS(ns, n, x, 0) |
| #define SER_NS_UINT32(ns, n, x) SER_NS_UINT32_FLAGS(ns, n, x, 0) |
| #define SER_NS_UINT64(ns, n, x) SER_NS_UINT64_FLAGS(ns, n, x, 0) |
| #define SER_NS_REAL32(ns, n, x) SER_NS_REAL32_FLAGS(ns, n, x, 0) |
| #define SER_NS_REAL64(ns, n, x) SER_NS_REAL64_FLAGS(ns, n, x, 0) |
| #define SER_NS_BOOL(ns, n, x) SER_NS_BOOL_FLAGS(ns, n, x, 0) |
| #define SER_NS_STR(ns, n, x) SER_NS_STR_FLAGS(ns, n, x, 0) |
| #define SER_NS_STRUCT(ns, n, x, t) SER_NS_STRUCT_FLAGS(ns, n, x, 0, t) |
| #define SER_NS_DYN_ARRAY(ns, n, mn, mx, t) \ |
| SER_NS_DYN_ARRAY_FLAGS(ns, n, mn, mx, 0, t) |
| |
| |
| // Serialization Info to skip in |
| #define SER_IN_INT8(n, x) SER_INT8_FLAGS(n, x, SER_IN) |
| #define SER_IN_UINT8(n, x) SER_UINT8_FLAGS(n, x, SER_IN) |
| #define SER_IN_INT16(n, x) SER_INT16_FLAGS(n, x, SER_IN) |
| #define SER_IN_UINT16(n, x) SER_UINT16_FLAGS(n, x, SER_IN) |
| #define SER_IN_UINT32(n, x) SER_UINT32_FLAGS(n, x, SER_IN) |
| #define SER_IN_UINT32(n, x) SER_UINT32_FLAGS(n, x, SER_IN) |
| #define SER_IN_INT64(n, x) SER_INT64_FLAGS(n, x, SER_IN) |
| #define SER_IN_UINT64(n, x) SER_UINT64_FLAGS(n, x, SER_IN) |
| #define SER_IN_REAL32(n, x) SER_REAL32_FLAGS(n, x, SER_IN) |
| #define SER_IN_REAL64(n, x) SER_REAL64_FLAGS(n, x, SER_IN) |
| #define SER_IN_BOOL(n, x) SER_BOOL_FLAGS(n, x, SER_IN) |
| #define SER_IN_STR(n, x) SER_STR_FLAGS(n, x, SER_IN) |
| #define SER_IN_STRUCT(n, x, t) SER_STRUCT_FLAGS(n, x, SER_IN, t) |
| #define SER_IN_DYN_ARRAY(n, mn, mx, t) \ |
| SER_DYN_ARRAY_FLAGS(n, mn, mx, SER_IN, t) |
| #define SER_NS_IN_INT8(ns, n, x) SER_NS_INT8_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_UINT8(ns, n, x) SER_NS_UINT8_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_INT16(ns, n, x) SER_NS_INT16_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_UINT16(ns, n, x) SER_NS_UINT16_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_INT32(ns, n, x) SER_NS_INT32_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_UINT32(ns, n, x) SER_NS_UINT32_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_INT64(ns, n, x) SER_NS_INT64_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_UINT64(ns, n, x) SER_NS_UINT64_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_REAL32(ns, n, x) SER_NS_REAL32_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_REAL64(ns, n, x) SER_NS_REAL64_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_BOOL(ns, n, x) SER_NS_BOOL_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_STR(ns, n, x) SER_NS_STR_FLAGS(ns, n, x, SER_IN) |
| #define SER_NS_IN_STRUCT(ns, n, x, t) SER_NS_STRUCT_FLAGS(ns, n, x, SER_IN, t) |
| #define SER_NS_IN_DYN_ARRAY(ns, n, mn, mx, t) \ |
| SER_NS_DYN_ARRAY_FLAGS(ns, n, mn, mx, SER_IN, t) |
| |
| // Serialization Info to skip out |
| #define SER_OUT_INT8(n, x) SER_INT8_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_UINT8(n, x) SER_UINT8_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_INT16(n, x) SER_INT16_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_UINT16(n, x) SER_UINT16_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_INT32(n, x) SER_INT32_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_UINT32(n, x) SER_UINT32_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_INT64(n, x) SER_INT64_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_UINT64(n, x) SER_UINT64_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_REAL32(n, x) SER_REAL32_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_REAL64(n, x) SER_REAL64_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_BOOL(n, x) SER_BOOL_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_STR(n, x) SER_STR_FLAGS(n, x, SER_OUT) |
| #define SER_OUT_STRUCT(n, x, t) SER_STRUCT_FLAGS(n, x, SER_OUT, t) |
| #define SER_OUT_DYN_ARRAY(n, mn, mx, t) \ |
| SER_DYN_ARRAY_FLAGS(n, mn, mx, SER_OUT, t) |
| #define SER_NS_OUT_INT8(ns, n, x) SER_NS_INT8_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_UINT8(ns, n, x) SER_NS_UINT8_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_INT16(ns, n, x) SER_NS_INT16_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_UINT16(ns, n, x) SER_NS_UINT16_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_INT32(ns, n, x) SER_NS_INT32_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_UINT32(ns, n, x) SER_NS_UINT32_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_INT64(ns, n, x) SER_NS_INT64_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_UINT64(ns, n, x) SER_NS_UINT64_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_REAL32(ns, n, x) SER_NS_REAL32_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_REAL64(ns, n, x) SER_NS_REAL64_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_BOOL(ns, n, x) SER_NS_BOOL_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_STR(ns, n, x) SER_NS_STR_FLAGS(ns, n, x, SER_OUT) |
| #define SER_NS_OUT_STRUCT(ns, n, x, t) SER_NS_STRUCT_FLAGS(ns, n, x, SER_OUT, t) |
| #define SER_NS_OUT_DYN_ARRAY(ns, n, mn, mx, t) \ |
| SER_NS_DYN_ARRAY_FLAGS(ns, n, mn, mx, SER_OUT, t) |
| |
| |
| // Serialization Info to skip inout |
| #define SER_INOUT_INT8(n, x) SER_INT8_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_UINT8(n, x) SER_UINT8_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_INT16(n, x) SER_INT16_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_UINT16(n, x) SER_UINT16_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_INT32(n, x) SER_INT32_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_UINT32(n, x) SER_UINT32_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_INT64(n, x) SER_INT64_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_UINT64(n, x) SER_UINT64_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_REAL32(n, x) SER_REAL32_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_REAL64(n, x) SER_REAL64_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_BOOL(n, x) SER_BOOL_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_STR(n, x) SER_STR_FLAGS(n, x, SER_IN | SER_OUT) |
| #define SER_INOUT_STRUCT(n, x, t) \ |
| SER_STRUCT_FLAGS(n, x, SER_IN | SER_OUT, t) |
| #define SER_INOUT_DYN_ARRAY(n, mn, mx, t) \ |
| SER_DYN_ARRAY_FLAGS(n, mn, mx, SER_IN | SER_OUT, t) |
| #define SER_NS_INOUT_INT8(ns, n, x) \ |
| SER_NS_INT8_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_UINT8(ns, n, x) \ |
| SER_NS_UINT8_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_INT16(ns, n, x) \ |
| SER_NS_INT16_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_UINT16(ns, n, x) \ |
| SER_NS_UINT16_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_INT32(ns, n, x) \ |
| SER_NS_INT32_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_UINT32(ns, n, x) \ |
| SER_NS_UINT32_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_INT64(ns, n, x) \ |
| SER_NS_INT64_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_UINT64(ns, n, x) \ |
| SER_NS_UINT64_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_REAL32(ns, n, x) \ |
| SER_NS_REAL32_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_REAL64(ns, n, x) \ |
| SER_NS_REAL64_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_BOOL(ns, n, x) \ |
| SER_NS_BOOL_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_STR(ns, n, x) \ |
| SER_NS_STR_FLAGS(ns, n, x, SER_IN | SER_OUT) |
| #define SER_NS_INOUT_STRUCT(ns, n, x, t) \ |
| SER_NS_STRUCT_FLAGS(ns, n, x, SER_IN | SER_OUT, t) |
| #define SER_NS_INOUT_DYN_ARRAY(ns, n, mn, mx, t) \ |
| SER_NS_DYN_ARRAY_FLAGS(ns, n, mn, mx, SER_IN | SER_OUT, t) |
| |
| |
| // TypeInfo structures for base types |
| // to use in dynamic arrays |
| |
| #define SER_TYPEINFO_UINT8 \ |
| XmlSerializerInfo uint8_TypeInfo[] = {\ |
| SER_UINT8("uint8", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT8 \ |
| XmlSerializerInfo int8_TypeInfo[] = {\ |
| SER_INT8("int8", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT8_ATTR \ |
| XmlSerializerInfo uint8_TypeInfo[] = {\ |
| SER_ATTR_NS_UINT8_FLAGS(NULL, "uint8", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT8_ATTR \ |
| XmlSerializerInfo int8_TypeInfo[] = {\ |
| SER_ATTR_NS_INT8_FLAGS(NULL, "int8", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT16 \ |
| XmlSerializerInfo uint16_TypeInfo[] = { \ |
| SER_UINT16("uint16", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT16 \ |
| XmlSerializerInfo int16_TypeInfo[] = { \ |
| SER_INT16("int16", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT16_ATTR \ |
| XmlSerializerInfo uint16_TypeInfo[] = { \ |
| SER_ATTR_NS_UINT16_FLAGS(NULL, "uint16", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT16_ATTR \ |
| XmlSerializerInfo int16_TypeInfo[] = { \ |
| SER_ATTR_NS_INT16_FLAGS(NULL, "int16", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT32 \ |
| XmlSerializerInfo uint32_TypeInfo[] = { \ |
| SER_UINT32("uint32", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT32 \ |
| XmlSerializerInfo int32_TypeInfo[] = { \ |
| SER_INT32("int32", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT32_ATTR \ |
| XmlSerializerInfo uint32_TypeInfo[] = { \ |
| SER_ATTR_NS_UINT32_FLAGS(NULL, "uint32", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT32_ATTR \ |
| XmlSerializerInfo int32_TypeInfo[] = { \ |
| SER_ATTR_NS_INT32_FLAGS(NULL, "int32", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT64 \ |
| XmlSerializerInfo uint64_TypeInfo[] = { \ |
| SER_UINT64("uint64", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT64 \ |
| XmlSerializerInfo int64_TypeInfo[] = { \ |
| SER_INT64("int64", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_UINT64_ATTR \ |
| XmlSerializerInfo uint64_TypeInfo[] = { \ |
| SER_ATTR_NS_UINT64_FLAGS(NULL, "uint64", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_INT64_ATTR \ |
| XmlSerializerInfo int64_TypeInfo[] = { \ |
| SER_ATTR_NS_INT64_FLAGS(NULL, "int64", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_REAL32 \ |
| XmlSerializerInfo real32_TypeInfo[] = { \ |
| SER_REAL32("real32", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_REAL32_ATTR \ |
| XmlSerializerInfo real32_TypeInfo[] = { \ |
| SER_ATTR_NS_REAL32_FLAGS(NULL, "real32", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_REAL64 \ |
| XmlSerializerInfo real64_TypeInfo[] = { \ |
| SER_REAL32("real64", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_REAL64_ATTR \ |
| XmlSerializerInfo real64_TypeInfo[] = { \ |
| SER_ATTR_NS_REAL64_FLAGS(NULL, "real64", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_BOOL \ |
| XmlSerializerInfo bool_TypeInfo[] = {\ |
| SER_BOOL("bool", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_BOOL_ATTR \ |
| XmlSerializerInfo bool_TypeInfo[] = { \ |
| SER_ATTR_NS_BOOL_FLAGS(NULL, "bool", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| |
| #define SER_TYPEINFO_STRING \ |
| XmlSerializerInfo string_TypeInfo[] = { \ |
| SER_STR("string", 1), \ |
| SER_NULL \ |
| } |
| #define SER_TYPEINFO_STRING_ATTR \ |
| XmlSerializerInfo string_attr_TypeInfo[] = { \ |
| SER_ATTR_NS_STR_FLAGS(NULL, "string", 1, SER_ATTRS), \ |
| SER_NULL \ |
| } |
| |
| // Define to declare TypeInfo for structures |
| |
| #define SER_DECLARE_TYPE(t)\ |
| extern XmlSerializerInfo t##_TypeInfo[];\ |
| extern XmlSerializerInfo t##_TypeItems[] |
| |
| |
| // Defines to define TypeInfo for structures |
| |
| #define SER_START_ITEMS(t) \ |
| XmlSerializerInfo t##_TypeItems[] = \ |
| { |
| |
| #define SER_END_ITEMS(t) \ |
| SER_NULL \ |
| }; \ |
| \ |
| XmlSerializerInfo t##_TypeInfo[] = {\ |
| SER_STRUCT_FLAGS(NULL, 1, 0, t), \ |
| SER_NULL \ |
| } |
| |
| |
| // TypeInfo structures for well known types |
| |
| // XmlSerializationProc functions for different types |
| |
| int do_serialize_uint8(struct __XmlSerializationData* data); |
| int do_serialize_uint16(struct __XmlSerializationData* data); |
| int do_serialize_uint32(struct __XmlSerializationData* data); |
| int do_serialize_uint64(struct __XmlSerializationData* data); |
| int do_serialize_int8(struct __XmlSerializationData* data); |
| int do_serialize_int16(struct __XmlSerializationData* data); |
| int do_serialize_int32(struct __XmlSerializationData* data); |
| int do_serialize_int64(struct __XmlSerializationData* data); |
| int do_serialize_real32(struct __XmlSerializationData* data); |
| int do_serialize_real64(struct __XmlSerializationData* data); |
| int do_serialize_string(struct __XmlSerializationData* data); |
| int do_serialize_bool(struct __XmlSerializationData* data); |
| int do_serialize_dyn_size_array(struct __XmlSerializationData* data); |
| int do_serialize_struct(struct __XmlSerializationData* data); |
| int do_serialize_attrs(struct __XmlSerializationData* data); |
| |
| int ws_havenilvalue(XML_NODE_ATTR *attrs); |
| |
| |
| // Serializer user interface |
| |
| int ws_serialize(WsSerializerContextH serctx, |
| WsXmlNodeH xmlNode, |
| XML_TYPE_PTR dataPtr, |
| XmlSerializerInfo *info, |
| const char *name, |
| const char *ns, |
| XML_NODE_ATTR *attrs, |
| int output); |
| |
| void *ws_deserialize(WsSerializerContextH serctx, |
| WsXmlNodeH xmlParent, |
| XmlSerializerInfo *info, |
| const char *name, |
| const char *ns, |
| XML_NODE_ATTR **attrs, |
| int index, |
| int output); |
| |
| |
| |
| int ws_serialize_str(WsSerializerContextH serctx, |
| WsXmlNodeH parent, |
| const char *str, |
| const char *nameNs, |
| const char *name, |
| int mustunderstand); |
| |
| int ws_serialize_uint32( |
| WsSerializerContextH serctx, |
| WsXmlNodeH parent, |
| unsigned long val, |
| const char *nameNs, |
| const char *name, |
| int mustunderstand); |
| |
| char *ws_deserialize_str(WsSerializerContextH serctx, |
| WsXmlNodeH parent, |
| int index, |
| const char *nameNs, |
| const char *name); |
| |
| unsigned long ws_deserialize_uint32( |
| WsSerializerContextH serctx, |
| WsXmlNodeH parent, |
| int index, |
| const char *nameNs, |
| const char *name); |
| |
| int ws_deserialize_duration( |
| const char* text, |
| time_t *value); |
| |
| int ws_deserialize_datetime( |
| const char *text, |
| XML_DATETIME *tmx); |
| |
| |
| int ws_serializer_free_mem(WsSerializerContextH serctx, |
| XML_TYPE_PTR buf, |
| XmlSerializerInfo *info); |
| |
| |
| |
| |
| |
| |
| |
| /** @} */ |
| |
| #endif //WS_XML_SERIALIZER_H |
