/*******************************************************************************
* 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 <time.h>
#include "wsman-types.h"
#include "wsman-names.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;
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_INT8(ns, n, x) SER_NS_INT8_FLAGS(ns, n, x, 0)
#define SER_NS_UINT8(ns, n, x) SER_NS_UINT8_FLAGS(ns, n, x, 0)
#define SER_NS_INT16(ns, n, x) SER_NS_INT16_FLAGS(ns, n, x, 0)
#define SER_NS_UINT16(ns, n, x) SER_NS_UINT16_FLAGS(ns, n, x, 0)
#define SER_NS_INT32(ns, n, x) SER_NS_INT32_FLAGS(ns, n, x, 0)
#define SER_NS_UINT32(ns, n, x) SER_NS_UINT32_FLAGS(ns, n, x, 0)
#define SER_NS_INT64(ns, n, x) SER_NS_INT64_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