static void example12() { typedef struct { XML_TYPE_REAL32 value; XML_NODE_ATTR *attrs; } item; item org = {1.257,NULL}; SER_TYPEINFO_REAL32_ATTR; WsXmlDocH doc; WsXmlNodeH node = ws_xml_get_doc_root(doc); printf ("\n\n ******** example12. real32/64 deserialize/serialize ********\n"); WsSerializerContextH cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); int retval = ws_serialize(cntx, node, &org, real32_TypeInfo, "PowerState", NULL, NULL, 0); printf("ws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); item *con = (item *)ws_deserialize(cntx, node, real32_TypeInfo, "PowerState", NULL, NULL, 0, 0); if(con->value != org.value) { printf("Mismatched! org.value = %f con->value = %f\n", org.value, con->value); } ws_xml_destroy_doc(doc); ws_serializer_cleanup(cntx); }
static void example10() { char xmlstring[] = "<example><PowerState xsi:nil=\"true\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"/></example>"; // char xmlstring[] = "<example><PowerState state = \"critical\">5</PowerState></example>"; typedef struct { XML_TYPE_STR value; XML_NODE_ATTR *attrs; } item; SER_TYPEINFO_STRING_ATTR; WsXmlDocH doc = ws_xml_read_memory(xmlstring, strlen(xmlstring), "UTF-8", 0); WsXmlNodeH node = ws_xml_get_doc_root(doc); printf ("\n\n ******** example10. xsi:nil attibute test ********\n"); WsSerializerContextH cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } item *value = (item *)ws_deserialize(cntx, node, string_attr_TypeInfo, "PowerState", NULL, NULL, 0, 0); if(value->attrs) printf("*********attrs->ns = %s attrs->name = %s attrs->value = %s*********\n", value->attrs->ns, value->attrs->name, value->attrs->value); if(ws_havenilvalue(value->attrs)) printf("******** the attribute has xsi:nil ********\n"); ws_xml_destroy_doc(doc); ws_serializer_cleanup(cntx); }
static void example14() { typedef struct{ }empty; SER_START_ITEMS(empty) SER_END_ITEMS(empty); typedef struct { XML_TYPE_INT16 num; empty empty1; }A; SER_TYPEINFO_INT16; SER_START_ITEMS(A) SER_INT16("id",1), SER_NS_STRUCT(NULL, "empty", 1, empty), SER_END_ITEMS(A); A a1 = {-12, {}}; printf ("\n\n ******* example 14. serialize/de-serialze with empty t_TypeItems *******\n"); WsSerializerContextH cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } WsXmlDocH doc = ws_xml_create_doc(NULL, "example"); WsXmlNodeH node = ws_xml_get_doc_root(doc); empty values = {}; int ret = ws_serialize(cntx, node, &values, A_TypeInfo, CLASSNAME, NULL, NULL, 0); printf("serialize %i bytes\n", ret); ws_xml_dump_node_tree(stdout, node); void *ptr = ws_deserialize(cntx, node, A_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); printf("ptr = %p\n", ptr); ws_serializer_cleanup(cntx); }
int main(int argc, char *argv[]) { WsSerializerContextH cntx = ws_serializer_init(); // SoapH soap = ws_context_get_runtime(cntx); WsXmlDocH doc = ws_xml_read_file( argv[1], "UTF-8", 0 ); WsXmlNodeH node = ws_xml_get_soap_body(doc); if (!node) printf("no xml\n"); //node = ws_xml_get_child(node, 0, NULL, NULL); CIM_ComputerSystem *cs = (CIM_ComputerSystem *)ws_deserialize(cntx, node, CIM_ComputerSystem_TypeInfo, "CIM_ComputerSystem", NULL, NULL, 0, 0); if (cs == NULL) { printf("No cs\n"); return 1; } printf("NameFormat = <%s>\n", cs->NameFormat); /* printf("test[0] <%s>\n", cs->test[0]); printf("test[1] <%s>\n", cs->test[1]); printf("cs->foo.count = %d\n", cs->foo.count); if (cs->foo.data == NULL) { printf("No cs->foo.data\n"); return 1; } int i; char **p = (char **)cs->foo.data; for (i = 0; i < cs->foo.count; i++) { printf(" foo[%d] = <%s>\n", i, *p); p++; } */ return 0; }
static void example13() { XML_TYPE_UINT8 myshorts[] = { 5, 11, 14}; typedef struct { XML_TYPE_UINT16 id; XML_TYPE_DYN_ARRAY shorts; }item; XML_TYPE_DYN_ARRAY array_int8; SER_TYPEINFO_UINT8; SER_TYPEINFO_UINT16; SER_START_ITEMS(item) SER_INT16("id", 1), SER_DYN_ARRAY("temp", 0, 100, uint8), SER_END_ITEMS(item); char xmlstring[] = "<example><Sample><id>3</id></Sample></example>"; printf ("\n\n ****** example 13. de-serialize to int8 array (empty array de-serialization test) ******\n"); WsXmlDocH doc = ws_xml_read_memory(xmlstring, strlen(xmlstring), "UTF-8", 0); WsXmlNodeH node = ws_xml_get_doc_root(doc); WsSerializerContextH cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } item *desvalue = (item *)ws_deserialize(cntx, node, item_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); printf("desvlaue = %p\n", desvalue); array_int8 = desvalue->shorts; int i = 0; printf("id = %d, array_int8->count = %d\n",desvalue->id, array_int8.count); while(i < array_int8.count) { printf("%d ", ((char *)array_int8.data)[i]); i++; } printf("\n"); ws_serializer_cleanup(cntx); }
static void example9(void) { typedef struct { }empty; SER_START_ITEMS(empty) SER_END_ITEMS(empty); char xmlstring[] = "<example></example>"; WsXmlDocH doc = ws_xml_read_memory(xmlstring, strlen(xmlstring), "UTF-8", 0); WsXmlNodeH node = ws_xml_get_doc_root(doc); WsSerializerContextH cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } void *ptr = NULL; ptr = ws_deserialize(cntx, node, empty_TypeItems, NULL, NULL, NULL, 0, 0); printf("ptr = %p\n", ptr); ws_serializer_cleanup(cntx); }
/* This function guarantees that query is freed, even on failure */ int hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, XmlSerializerInfo *serializerInfo, const char *resourceUri, const char *className, hypervObject **list) { int result = -1; WsSerializerContextH serializerContext; client_opt_t *options = NULL; char *query_string = NULL; filter_t *filter = NULL; WsXmlDocH response = NULL; char *enumContext = NULL; hypervObject *head = NULL; hypervObject *tail = NULL; WsXmlNodeH node = NULL; XML_TYPE_PTR data = NULL; hypervObject *object; if (virBufferCheckError(query) < 0) { virBufferFreeAndReset(query); return -1; } query_string = virBufferContentAndReset(query); if (list == NULL || *list != NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument")); VIR_FREE(query_string); return -1; } serializerContext = wsmc_get_serialization_context(priv->client); options = wsmc_options_init(); if (options == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not initialize options")); goto cleanup; } filter = filter_create_simple(WSM_WQL_FILTER_DIALECT, query_string); if (filter == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not create filter")); goto cleanup; } response = wsmc_action_enumerate(priv->client, root, options, filter); if (hyperyVerifyResponse(priv->client, response, "enumeration") < 0) goto cleanup; enumContext = wsmc_get_enum_context(response); ws_xml_destroy_doc(response); response = NULL; while (enumContext != NULL && *enumContext != '\0') { response = wsmc_action_pull(priv->client, resourceUri, options, filter, enumContext); if (hyperyVerifyResponse(priv->client, response, "pull") < 0) goto cleanup; node = ws_xml_get_soap_body(response); if (node == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not lookup SOAP body")); goto cleanup; } node = ws_xml_get_child(node, 0, XML_NS_ENUMERATION, WSENUM_PULL_RESP); if (node == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not lookup pull response")); goto cleanup; } node = ws_xml_get_child(node, 0, XML_NS_ENUMERATION, WSENUM_ITEMS); if (node == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not lookup pull response items")); goto cleanup; } if (ws_xml_get_child(node, 0, resourceUri, className) == NULL) break; data = ws_deserialize(serializerContext, node, serializerInfo, className, resourceUri, NULL, 0, 0); if (data == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not deserialize pull response item")); goto cleanup; } if (VIR_ALLOC(object) < 0) goto cleanup; object->serializerInfo = serializerInfo; object->data = data; data = NULL; if (head == NULL) { head = object; } else { tail->next = object; } tail = object; VIR_FREE(enumContext); enumContext = wsmc_get_enum_context(response); ws_xml_destroy_doc(response); response = NULL; } *list = head; head = NULL; result = 0; cleanup: if (options != NULL) wsmc_options_destroy(options); if (filter != NULL) filter_destroy(filter); if (data != NULL) { #if WS_SERIALIZER_FREE_MEM_WORKS /* FIXME: ws_serializer_free_mem is broken in openwsman <= 2.2.6, * see hypervFreeObject for a detailed explanation. */ if (ws_serializer_free_mem(serializerContext, data, serializerInfo) < 0) { VIR_ERROR(_("Could not free deserialized data")); } #endif } VIR_FREE(query_string); ws_xml_destroy_doc(response); VIR_FREE(enumContext); hypervFreeObject(priv, head); return result; }
static void example11() { typedef struct { XML_TYPE_INT8 byte1; XML_TYPE_INT32 int1; XML_TYPE_INT8 byte2; } Foo; typedef struct { XML_TYPE_INT8 byte1; XML_TYPE_INT16 short1; XML_TYPE_INT32 int1; char *string1; Foo foo; } Sample; Sample sample = { -1, -127, 4, "string", {-12, 196, 8} }; SER_START_ITEMS(Foo) SER_INT8("FOOBYTE1", 1), SER_INT32("FOOINT32", 1), SER_INT8("FOOBYTE2", 1), SER_END_ITEMS(Foo); SER_START_ITEMS(Sample) SER_INT8("BYTE", 1), SER_INT16("SHORT", 1), SER_INT32("INT32", 1), SER_STR("STRING", 1), SER_STRUCT("FOO", 1, Foo), SER_END_ITEMS(Sample); WsSerializerContextH cntx; WsXmlDocH doc; WsXmlNodeH node; int retval; printf ("\n\n ******** example11. Structure with pads (signed int test). ********\n"); cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, CLASSNAME, NULL, NULL, 0); printf("ws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); node = ws_xml_get_doc_root(doc); Sample *cs = (Sample *) ws_deserialize(cntx, node, Sample_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); if (cs == NULL) { printf("Errror ws_deserialize\n"); return; } printf("\n initial and deserialized structures\n"); printf(" byte1 = %d : %d\n", sample.byte1, cs->byte1); printf(" short1 = %d : %d\n", sample.short1, cs->short1); printf(" int1 = %d : %d\n", sample.int1, cs->int1); printf(" string1 = <%s> : <%s>\n", sample.string1, cs->string1); printf(" foo :\n"); printf(" byte1 = %d : %d\n", sample.foo.byte1, cs->foo.byte1); printf(" int1 = %d : %d\n", sample.foo.int1, cs->foo.int1); printf(" byte2 = %d : %d\n", sample.foo.byte2, cs->foo.byte2); }
static void example7(void) { typedef struct { XML_TYPE_STR value; XML_NODE_ATTR *attrs; } Selector; SER_TYPEINFO_STRING_ATTR; typedef struct { XML_TYPE_DYN_ARRAY selectors; } SelectorSet; SER_START_ITEMS(SelectorSet) SER_NS_DYN_ARRAY(XML_NS_WS_MAN, WSM_SELECTOR, 0, 1000, string_attr), SER_END_ITEMS(SelectorSet); typedef struct { XML_TYPE_STR uri; SelectorSet selectorset; } ReferenceParameters; SER_START_ITEMS(ReferenceParameters) SER_NS_STR(XML_NS_WS_MAN, WSM_RESOURCE_URI, 1), SER_NS_STRUCT(XML_NS_WS_MAN, WSM_SELECTOR_SET, 1, SelectorSet), SER_END_ITEMS(ReferenceParameters); typedef struct { XML_TYPE_STR address; ReferenceParameters refparams; } EPR; SER_START_ITEMS(EPR) SER_NS_STR(XML_NS_ADDRESSING, WSA_ADDRESS, 1), SER_NS_STRUCT(XML_NS_ADDRESSING, WSA_REFERENCE_PARAMETERS, 1, ReferenceParameters), SER_END_ITEMS(EPR); XML_NODE_ATTR attrs[3] = { {NULL, NULL, "Name", "SelName1"}, {NULL, NULL, "Name", "SelName2"}, {NULL, NULL, "Name", "SelName3"}, }; Selector selectors[] = { {"selector1", &attrs[0]}, {"selector2", &attrs[1]}, {"selector3", &attrs[2]} }; EPR Epr = { "http://localhost:8889/wsman", {"http://acme.org/hardware/2005/02/storage/physDisk", {{3, selectors}} } }; WsSerializerContextH cntx; WsXmlDocH doc; WsXmlNodeH node; int retval; printf ("\n\n ******** example7. Endpoint Reference ********\n"); cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); retval = ws_serialize(cntx, node, &Epr, EPR_TypeInfo, "EndpointReference", XML_NS_ADDRESSING, NULL, 0); printf("\n\nws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); EPR *newEPR; node = ws_xml_get_doc_root(doc); printf("\n\nws_deserialize:\n"); newEPR = (EPR *) ws_deserialize(cntx, node, EPR_TypeInfo, "EndpointReference", XML_NS_ADDRESSING, NULL, 0, 0); if (newEPR == NULL) { printf("Errror ws_deserialize\n"); return; } printf("**** Deserialized document *****\n"); printf("address = %s\n", newEPR->address); printf("refparams.uri = %s\n", newEPR->refparams.uri); int i; Selector *ss = (Selector *) newEPR->refparams.selectorset.selectors.data; if (ss == NULL) { printf (" !!!! newEPR->refparams.selectors.data == NULL\n"); return; } for (i = 0; i < newEPR->refparams.selectorset.selectors.count; i++) { Selector *s; s = ss + i; printf(" Selector("); XML_NODE_ATTR *a = s->attrs; while (a) { printf("%s:%s=%s", a->ns ? a->ns : "", a->name, a->value); a = a->next; } printf(") = %s\n", s->value); } }
static void example1(void) { #define EX1_NS "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem" XML_TYPE_UINT16 myshorts[] = { 5, 11, 14, 19, 27, 36 }; SER_TYPEINFO_UINT16; struct __Sample_Servie { XML_TYPE_BOOL AcceptPause; XML_TYPE_BOOL AcceptStop; XML_TYPE_STR Caption; XML_TYPE_UINT32 CheckPoint; XML_TYPE_STR CreationClassName; XML_TYPE_STR Description; XML_TYPE_BOOL DesktopInteract; XML_TYPE_STR DisplayName; XML_TYPE_STR ErrorControl; XML_TYPE_UINT32 ExitCode; XML_TYPE_STR InstallDate; XML_TYPE_STR Name; XML_TYPE_STR PathName; XML_TYPE_UINT32 ProcessId; XML_TYPE_UINT32 ServiceSpecificExitCode; XML_TYPE_STR ServiceType; XML_TYPE_BOOL Started; XML_TYPE_STR StartMode; XML_TYPE_STR StartName; XML_TYPE_STR State; XML_TYPE_STR Status; XML_TYPE_STR SystemCreationClassName; XML_TYPE_STR SystemName; XML_TYPE_UINT32 TagId; XML_TYPE_UINT32 WaitHint; XML_TYPE_UINT64 Uint64; XML_TYPE_DYN_ARRAY shorts; }; typedef struct __Sample_Servie Sample_Servie; Sample_Servie servie = { 0, 1, "Caption", 30, "CreationClassName", "Description", 1, "DisplayName", "ErrorControl", 50, "InstallDate", "Name", "PathName", 60, 70, "ServiceType", 0, "StartMode", "StartName", "State", "Status", "SystemCreationClassName", "SystemName", 90, 100, 1000000, {6, myshorts } }; SER_START_ITEMS(Sample_Servie) SER_BOOL("AcceptPause", 1), SER_BOOL("AcceptStop", 1), SER_STR("Caption", 1), SER_UINT32("CheckPoint", 1), SER_STR("CreationClassName", 1), SER_STR("Description", 1), SER_BOOL("DesktopInteract", 1), SER_NS_STR(EX1_NS, "DisplayName", 1), SER_STR("ErrorControl", 1), SER_UINT32("ExitCode", 1), SER_STR("InstallDate", 1), SER_STR("Name", 1), SER_STR("PathName", 1), SER_UINT32("ProcessId", 1), SER_UINT32("ServiceSpecificExitCode", 1), SER_STR("ServiceType", 1), SER_BOOL("Started", 1), SER_STR("StartMode", 1), SER_STR("StartName", 1), SER_STR("State", 1), SER_STR("Status", 1), SER_STR("SystemCreationClassName", 1), SER_STR("SystemName", 1), SER_UINT32("TagId", 1), SER_UINT32("WaitHint", 1), SER_UINT64("Uint64", 1), SER_DYN_ARRAY("shorts", 0, 1000, uint16), SER_END_ITEMS(Sample_Servie); WsSerializerContextH cntx; WsXmlDocH doc; WsXmlNodeH node; int retval; printf("\n\n ******** example1. Basic types ********\n"); cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); retval = ws_serialize(cntx, node, &servie, Sample_Servie_TypeInfo, CLASSNAME, NULL, NULL, 0); printf("ws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); node = ws_xml_get_doc_root(doc); //WsXmlDocH xx = ws_xml_read_file( ws_context_get_runtime(cntx), "./test.xml", "UTF-8", 0 ); //node = ws_xml_get_doc_root(xx); Sample_Servie *cs = (Sample_Servie *) ws_deserialize(cntx, node, Sample_Servie_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); if (cs == NULL) { printf("Error in ws_serialize\n"); return; } retval = memcmp(cs, &servie, sizeof(servie)); if (retval) { printf("Not compared (%d) - FAILED\n", retval); printf("%d : %d\n", servie.AcceptPause, cs->AcceptPause); printf("%d : %d\n", servie.AcceptStop, cs->AcceptStop); printf("%s : %s\n", servie.Caption, cs->Caption); } }
static void example6(void) { typedef struct { struct { XML_TYPE_UINT8 body; XML_NODE_ATTR *attrs; } uint8_with_attrs; struct { XML_TYPE_UINT16 body; XML_NODE_ATTR *attrs; } uint16_with_attrs; struct { XML_TYPE_UINT32 body; XML_NODE_ATTR *attrs; } uint32_with_attrs; struct { XML_TYPE_BOOL body; XML_NODE_ATTR *attrs; } bool_with_attrs; struct { XML_TYPE_STR body; XML_NODE_ATTR *attrs; } str_with_attrs; } Dummy; typedef struct { struct { Dummy body; XML_NODE_ATTR *attrs; } struct_with_attrs; } Sample; XML_NODE_ATTR attrs[] = { {NULL, NULL, "Uint8AttrName1", "Uint8AttrValue1"}, {NULL, NULL, "Uint16AttrName1", "Uint16AttrValue1"}, {NULL, NULL, "Uint32AttrName1", "Uint32AttrValue1"}, {NULL, NULL, "BoolAttrName1", "BoolAttrValue1"}, {NULL, NULL, "StringAttrName1", "StringAttrValue1"}, }; XML_NODE_ATTR str_attrs[3] = { {NULL, NULL, "AttrName1", "AttrValue1"}, {NULL, NULL, "AttrName2", "AttrValue2"}, {NULL, XML_NS_ADDRESSING, "AttrQName", "AttrValue3"}, }; Sample sample = { { { {8, &attrs[0]}, {16, &attrs[1]}, {32, &attrs[2]}, {0, &attrs[3]}, {"string", &attrs[4]}, }, &str_attrs[0] } }; str_attrs[0].next = &str_attrs[1]; str_attrs[1].next = &str_attrs[2]; SER_START_ITEMS(Dummy) SER_ATTR_NS_UINT8_FLAGS(NULL, "UINT8", 1, 0), SER_ATTR_NS_UINT16_FLAGS(NULL, "UINT16", 1, 0), SER_ATTR_NS_UINT32_FLAGS(NULL, "UINT32", 1, 0), SER_ATTR_NS_BOOL_FLAGS(NULL, "BOOL", 1, 0), SER_ATTR_NS_STR_FLAGS(NULL, "STRING", 1, 0), SER_END_ITEMS(Dummy); SER_START_ITEMS(Sample) SER_ATTR_NS_STRUCT_FLAGS(XML_NS_WS_MAN, "STRUCT", 1, 0, Dummy), SER_END_ITEMS(Sample); WsSerializerContextH cntx; WsXmlDocH doc; WsXmlNodeH node; int retval; printf ("\n\n ******** example 6. Nodes with attributes ********\n"); cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, CLASSNAME, XML_NS_WS_MAN, NULL, 0); printf("\n\nws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); Sample *news; printf("\n\nws_deserialize:\n"); news = (Sample *) ws_deserialize(cntx, node, Sample_TypeInfo, CLASSNAME, XML_NS_ADDRESSING, NULL, 0, 0); if (news == NULL) { printf("Errror ws_deserialize\n"); return; } XML_NODE_ATTR *nattrs; Dummy *dm = &(news->struct_with_attrs.body); printf("**** Deserialized document %p *****\n", news); printf("struct_with_attrs.body ("); nattrs = news->struct_with_attrs.attrs; while (nattrs) { printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, nattrs->value); nattrs = nattrs->next; } printf(")\n"); printf(" uint8_with_attrs = %d (", dm->uint8_with_attrs.body); nattrs = dm->uint8_with_attrs.attrs; while (nattrs) { printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, nattrs->value); nattrs = nattrs->next; } printf(")\n"); printf(" uint16_with_attrs = %d (", dm->uint16_with_attrs.body); nattrs = dm->uint16_with_attrs.attrs; while (nattrs) { printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, nattrs->value); nattrs = nattrs->next; } printf(")\n"); printf(" uint32_with_attrs = %d (", dm->uint32_with_attrs.body); nattrs = dm->uint32_with_attrs.attrs; while (nattrs) { printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, nattrs->value); nattrs = nattrs->next; } printf(")\n"); printf(" bool_with_attrs = %d (", dm->bool_with_attrs.body); nattrs = dm->bool_with_attrs.attrs; while (nattrs) { printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, nattrs->value); nattrs = nattrs->next; } printf(")\n"); printf(" str_with_attrs = %s (", dm->str_with_attrs.body); nattrs = dm->str_with_attrs.attrs; while (nattrs) { printf("%s:%s=\"%s\" ", nattrs->ns, nattrs->name, nattrs->value); nattrs = nattrs->next; } printf(")\n"); }
static void example5(void) { typedef struct { XML_TYPE_BOOL AcceptPause; XML_TYPE_STR Caption; } Foo; Foo foos[] = { {1, "Caption 1"}, {0, "Caption 2"}, {1, "Caption 1",}, {0, "Caption 2",}, }; SER_START_ITEMS(Foo) SER_BOOL("AcceptPause", 1), SER_STR("Caption", 1), SER_END_ITEMS(Foo); XML_TYPE_UINT16 myshorts[] = { 5, 11, 14, 19, 27, 36 }; SER_TYPEINFO_UINT16; typedef struct { XML_TYPE_STR city; XML_TYPE_DYN_ARRAY shorts; XML_TYPE_DYN_ARRAY foos; XML_TYPE_UINT16 tag; } Sample; Sample sample = { "Moscow", {6, myshorts}, {2, foos}, 99 }; SER_START_ITEMS(Sample) SER_STR("city", 1), SER_DYN_ARRAY("shorts", 0, 1000, uint16), SER_DYN_ARRAY("foos", 0, 1000, Foo), SER_UINT16("tag", 1), SER_END_ITEMS(Sample); WsSerializerContextH cntx; WsXmlDocH doc; WsXmlNodeH node; int retval; printf("\n\n ******** example 5: Dynamic arrays ********\n"); cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, CLASSNAME, NULL, NULL, 0); printf("\n\nws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); node = ws_xml_get_doc_root(doc); printf("\n\nws_deserialize:\n"); Sample *cs = (Sample *) ws_deserialize(cntx, node, Sample_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); if (cs == NULL) { printf("Error ws_deserialize\n"); return; } int i; printf("shorts count = %d\n", cs->shorts.count); printf("foos count = %d\n", cs->foos.count); printf("\n"); printf(" city = <%s>\n", cs->city); if (cs->shorts.data == NULL) { printf("No uint16 objects\n"); goto AFTER_SHORTS; } unsigned short *newuints = (unsigned short *) cs->shorts.data; printf(" shorts = {"); for (i = 0; i < cs->shorts.count; i++) { printf("%u, ", *newuints); newuints++; } printf("}\n"); AFTER_SHORTS: if (cs->foos.data == NULL) { printf("No foo objects\n"); goto AFTER_FOOS; } Foo *newfoos = cs->foos.data; for (i = 0; i < cs->foos.count; i++) { printf(" ==== Foo %d =====\n", i); printf(" AcceptPause = %d\n", newfoos->AcceptPause); printf(" Caption = <%s>\n", newfoos->Caption); printf(" ==== End of Foo %d =====\n", i); newfoos++; } AFTER_FOOS: printf(" tag = %d\n", cs->tag); }
static void example3(void) { typedef struct { XML_TYPE_UINT8 a; XML_TYPE_UINT8 b; XML_TYPE_UINT8 c; XML_TYPE_UINT8 pad; XML_TYPE_STR string; } Sample; SER_START_ITEMS(Sample) SER_UINT8("a", 1), SER_UINT8("b", 1), SER_UINT8("c", 1), SER_IN_UINT8("pad", 1), SER_STR("string", 1), SER_END_ITEMS(Sample); Sample sample = { 'a', 'b', 'c', 'x', "simple string" }; // Sample *p = NULL; WsSerializerContextH cntx; WsXmlDocH doc; WsXmlNodeH node; int retval; printf("\n\n ******** example3. Skip elements. ********\n"); cntx = ws_serializer_init(); if (cntx == NULL) { printf("Error ws_create_runtime\n"); return; } doc = ws_xml_create_doc( NULL, "example"); node = ws_xml_get_doc_root(doc); retval = ws_serialize(cntx, node, &sample, Sample_TypeInfo, CLASSNAME, NULL, NULL, 0); printf("ws_serialize: %d\n", retval); ws_xml_dump_node_tree(stdout, node); printf("\n\nws_deserialize (prints original : result):\n"); node = ws_xml_get_doc_root(doc); Sample *cs = (Sample *) ws_deserialize(cntx, node, Sample_TypeInfo, CLASSNAME, NULL, NULL, 0, 0); if (cs == NULL) { printf("Errror ws_serialize\n"); return; } printf("a = %c : %c\n", sample.a, cs->a); printf("b = %c : %c\n", sample.b, cs->b); printf("c = %c : %c\n", sample.c, cs->c); printf("pad = %c(%d) : %c(%d)\n", sample.pad, sample.pad, cs->pad, cs->pad); printf("string = <%s> : <%s>\n", sample.string, cs->string); }