User Tools

Site Tools


Differences

This shows you the differences between two versions of the page.

Link to this comparison view

cpp:gsoap-hello [2019-03-18 10:05] (current)
Line 1: Line 1:
 +=====h.hello.req.xml====
 +<code h.hello.req.xml>​
 +<?xml version="​1.0"​ encoding="​UTF-8"?>​
 +<​SOAP-ENV:​Envelope
 +    xmlns:​SOAP-ENV="​http://​schemas.xmlsoap.org/​soap/​envelope/"​
 +    xmlns:​SOAP-ENC="​http://​schemas.xmlsoap.org/​soap/​encoding/"​
 +    xmlns:​xsi="​http://​www.w3.org/​2001/​XMLSchema-instance"​
 +    xmlns:​xsd="​http://​www.w3.org/​2001/​XMLSchema"​
 +    xmlns:​h="​http://​tempuri.org/​h.xsd">​
 + <​SOAP-ENV:​Body>​
 +  <​h:​hello>​
 +  </​h:​hello>​
 + </​SOAP-ENV:​Body>​
 +</​SOAP-ENV:​Envelope>​
 +</​code>​
 +
 +=====h.hello.res.xml====
 +<code h.hello.res.xml>​
 +<?xml version="​1.0"​ encoding="​UTF-8"?>​
 +<​SOAP-ENV:​Envelope
 +    xmlns:​SOAP-ENV="​http://​schemas.xmlsoap.org/​soap/​envelope/"​
 +    xmlns:​SOAP-ENC="​http://​schemas.xmlsoap.org/​soap/​encoding/"​
 +    xmlns:​xsi="​http://​www.w3.org/​2001/​XMLSchema-instance"​
 +    xmlns:​xsd="​http://​www.w3.org/​2001/​XMLSchema"​
 +    xmlns:​h="​http://​tempuri.org/​h.xsd">​
 + <​SOAP-ENV:​Body>​
 +  <​h:​helloResponse>​
 +   <​param-1></​param-1>​
 +  </​h:​helloResponse>​
 + </​SOAP-ENV:​Body>​
 +</​SOAP-ENV:​Envelope>​
 +</​code>​
 +
 +=====h.nsmap====
 +<code h.nsmap>
 +
 +#include "​stdsoap2.h"​
 +/* This defines the global XML namespaces[] table to #include and compile */
 +SOAP_NMAC struct Namespace namespaces[] = {
 +        { "​SOAP-ENV",​ "​http://​schemas.xmlsoap.org/​soap/​envelope/",​ "​http://​www.w3.org/​*/​soap-envelope",​ NULL },
 +        { "​SOAP-ENC",​ "​http://​schemas.xmlsoap.org/​soap/​encoding/",​ "​http://​www.w3.org/​*/​soap-encoding",​ NULL },
 +        { "​xsi",​ "​http://​www.w3.org/​2001/​XMLSchema-instance",​ "​http://​www.w3.org/​*/​XMLSchema-instance",​ NULL },
 +        { "​xsd",​ "​http://​www.w3.org/​2001/​XMLSchema",​ "​http://​www.w3.org/​*/​XMLSchema",​ NULL },
 +        { "​h",​ "​http://​tempuri.org/​h.xsd",​ NULL, NULL },
 +        { NULL, NULL, NULL, NULL}
 +    };
 +</​code>​
 +
 +=====h.wsdl====
 +<code h.wsdl>
 +<?xml version="​1.0"​ encoding="​UTF-8"?>​
 +<​definitions name="​Service"​
 +  targetNamespace="​http://​tempuri.org/​h.xsd/​Service.wsdl"​
 +  xmlns:​tns="​http://​tempuri.org/​h.xsd/​Service.wsdl"​
 +  xmlns:​SOAP-ENV="​http://​schemas.xmlsoap.org/​soap/​envelope/"​
 +  xmlns:​SOAP-ENC="​http://​schemas.xmlsoap.org/​soap/​encoding/"​
 +  xmlns:​xsi="​http://​www.w3.org/​2001/​XMLSchema-instance"​
 +  xmlns:​xsd="​http://​www.w3.org/​2001/​XMLSchema"​
 +  xmlns:​h="​http://​tempuri.org/​h.xsd"​
 +  xmlns:​SOAP="​http://​schemas.xmlsoap.org/​wsdl/​soap/"​
 +  xmlns:​HTTP="​http://​schemas.xmlsoap.org/​wsdl/​http/"​
 +  xmlns:​MIME="​http://​schemas.xmlsoap.org/​wsdl/​mime/"​
 +  xmlns:​DIME="​http://​schemas.xmlsoap.org/​ws/​2002/​04/​dime/​wsdl/"​
 +  xmlns:​WSDL="​http://​schemas.xmlsoap.org/​wsdl/"​
 +  xmlns="​http://​schemas.xmlsoap.org/​wsdl/">​
 +
 +<​types>​
 +
 +  <schema targetNamespace="​http://​tempuri.org/​h.xsd"​
 +    xmlns:​SOAP-ENV="​http://​schemas.xmlsoap.org/​soap/​envelope/"​
 +    xmlns:​SOAP-ENC="​http://​schemas.xmlsoap.org/​soap/​encoding/"​
 +    xmlns:​xsi="​http://​www.w3.org/​2001/​XMLSchema-instance"​
 +    xmlns:​xsd="​http://​www.w3.org/​2001/​XMLSchema"​
 +    xmlns:​h="​http://​tempuri.org/​h.xsd"​
 +    xmlns="​http://​www.w3.org/​2001/​XMLSchema"​
 +    elementFormDefault="​unqualified"​
 +    attributeFormDefault="​unqualified">​
 +    <import namespace="​http://​schemas.xmlsoap.org/​soap/​encoding/"/>​
 +    <!-- operation request element -->
 +    <element name="​hello">​
 +      <​complexType>​
 +          <​sequence>​
 +          </​sequence>​
 +      </​complexType>​
 +    </​element>​
 +    <!-- operation response element -->
 +    <element name="​helloResponse">​
 +      <​complexType>​
 +          <​sequence>​
 +            <element name="​param-1"​ type="​xsd:​string"​ minOccurs="​1"​ maxOccurs="​1"/><​!-- h__hello::​_param_1 -->
 +          </​sequence>​
 +      </​complexType>​
 +    </​element>​
 +  </​schema>​
 +
 +</​types>​
 +
 +<message name="​helloRequest">​
 +  <part name="​Body"​ element="​h:​hello"/><​!-- h__hello::​h__hello -->
 +</​message>​
 +
 +<message name="​helloResponse">​
 +  <part name="​Body"​ element="​h:​helloResponse"/>​
 +</​message>​
 +
 +<​portType name="​ServicePortType">​
 +  <​operation name="​hello">​
 +    <​documentation>​Service definition of function h__hello</​documentation>​
 +    <input message="​tns:​helloRequest"/>​
 +    <output message="​tns:​helloResponse"/>​
 +  </​operation>​
 +</​portType>​
 +
 +<binding name="​Service"​ type="​tns:​ServicePortType">​
 +  <​SOAP:​binding style="​document"​ transport="​http://​schemas.xmlsoap.org/​soap/​http"/>​
 +  <​operation name="​hello">​
 +    <​SOAP:​operation soapAction=""/>​
 +    <​input>​
 +          <​SOAP:​body use="​literal"​ parts="​Body"/>​
 +    </​input>​
 +    <​output>​
 +          <​SOAP:​body use="​literal"​ parts="​Body"/>​
 +    </​output>​
 +  </​operation>​
 +</​binding>​
 +
 +<service name="​Service">​
 +  <​documentation>​gSOAP 2.8.78 generated service definition</​documentation>​
 +  <port name="​Service"​ binding="​tns:​Service">​
 +    <​SOAP:​address location="​http://​localhost:​80"/>​
 +  </​port>​
 +</​service>​
 +
 +</​definitions>​
 +</​code>​
 +
 +=====h.xsd====
 +<code h.xsd>
 +<?xml version="​1.0"​ encoding="​UTF-8"?>​
 +  <schema targetNamespace="​http://​tempuri.org/​h.xsd"​
 +    xmlns:​SOAP-ENV="​http://​schemas.xmlsoap.org/​soap/​envelope/"​
 +    xmlns:​SOAP-ENC="​http://​schemas.xmlsoap.org/​soap/​encoding/"​
 +    xmlns:​xsi="​http://​www.w3.org/​2001/​XMLSchema-instance"​
 +    xmlns:​xsd="​http://​www.w3.org/​2001/​XMLSchema"​
 +    xmlns:​h="​http://​tempuri.org/​h.xsd"​
 +    xmlns="​http://​www.w3.org/​2001/​XMLSchema"​
 +    elementFormDefault="​unqualified"​
 +    attributeFormDefault="​unqualified">​
 +    <import namespace="​http://​schemas.xmlsoap.org/​soap/​encoding/"/>​
 +    <!-- operation request element -->
 +    <element name="​hello">​
 +      <​complexType>​
 +          <​sequence>​
 +          </​sequence>​
 +      </​complexType>​
 +    </​element>​
 +    <!-- operation response element -->
 +    <element name="​helloResponse">​
 +      <​complexType>​
 +          <​sequence>​
 +            <element name="​param-1"​ type="​xsd:​string"​ minOccurs="​1"​ maxOccurs="​1"/><​!-- h__hello::​_param_1 -->
 +          </​sequence>​
 +      </​complexType>​
 +    </​element>​
 +  </​schema>​
 +
 +</​code>​
 +
 +=====hello.h====
 +<code hello.h>
 +h__hello(char*&​);​
 +</​code>​
 +
 +=====helloclient.cpp====
 +<code helloclient.cpp>​
 +#include "​soapH.h"​
 +#include "​h.nsmap"​
 +int main() {
 +    char *s;
 +
 +    struct soap *soap = soap_new();
 +
 +    soap_call_h__hello(soap,​ "​http://​www.cs.fsu.edu/​~engelen/​hellolitserver.cgi",​ "",​ s);
 +
 +    printf("​%s\n",​ s);
 +
 +    soap_destroy(soap);​
 +
 +    soap_end(soap);​
 +
 +    soap_free(soap);​
 +
 +    return 0;
 +}
 +
 +</​code>​
 +
 +=====helloserver.cpp====
 +<code helloserver.cpp>​
 +#include "​soapH.h"​
 +#include "​h.nsmap"​
 +
 +int main() {
 +    return soap_serve(soap_new());​
 +}
 +
 +int h__hello(struct soap *soap, char *&s) {
 +    s = soap_strdup(soap,​ "Hello World!"​);​
 +    return SOAP_OK;
 +}
 +</​code>​
 +
 +=====soapC.cpp====
 +<code soapC.cpp>​
 +/* soapC.cpp
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +#if defined(__BORLANDC__)
 +#pragma option push -w-8060
 +#pragma option push -w-8004
 +#endif
 +
 +#include "​soapH.h"​
 +
 +SOAP_SOURCE_STAMP("​@(#​) soapC.cpp ver 2.8.78 2019-03-18 07:59:39 GMT")
 +
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap) {
 +    soap->​part = SOAP_IN_HEADER;​
 +    soap->​header = soap_in_SOAP_ENV__Header(soap,​ "​SOAP-ENV:​Header",​ soap->​header,​ NULL);
 +    soap->​part = SOAP_END_HEADER;​
 +    return soap->​header == NULL;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap) {
 +    if (soap->​version && soap->​header) {
 +        soap->​part = SOAP_IN_HEADER;​
 +        if (soap_out_SOAP_ENV__Header(soap,​ "​SOAP-ENV:​Header",​ 0, soap->​header,​ ""​))
 +            return soap->​error;​
 +        soap->​part = SOAP_END_HEADER;​
 +    }
 +    return SOAP_OK;
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap) {
 +    if (soap->​version && soap->​header)
 +        soap_serialize_SOAP_ENV__Header(soap,​ soap->​header);​
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap) {
 +    if (soap->​header == NULL) {
 +        if ((soap->​header = soap_new_SOAP_ENV__Header(soap)))
 +            soap_default_SOAP_ENV__Header(soap,​ soap->​header);​
 +    }
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap) {
 +    if (soap->​fault == NULL) {
 +        soap->​fault = soap_new_SOAP_ENV__Fault(soap,​ -1);
 +        if (soap->​fault == NULL)
 +            return;
 +    }
 +    if (soap->​version == 2 && soap->​fault->​SOAP_ENV__Code == NULL)
 +        soap->​fault->​SOAP_ENV__Code = soap_new_SOAP_ENV__Code(soap,​ -1);
 +    if (soap->​version == 2 && soap->​fault->​SOAP_ENV__Reason == NULL)
 +        soap->​fault->​SOAP_ENV__Reason = soap_new_SOAP_ENV__Reason(soap,​ -1);
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap) {
 +    if (soap->​fault)
 +        soap_serialize_SOAP_ENV__Fault(soap,​ soap->​fault);​
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap) {
 +    if (soap->​fault)
 +        return soap_put_SOAP_ENV__Fault(soap,​ soap->​fault,​ "​SOAP-ENV:​Fault",​ ""​);​
 +    return SOAP_OK;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap) {
 +    return (soap->​fault = soap_get_SOAP_ENV__Fault(soap,​ NULL, "​SOAP-ENV:​Fault",​ NULL)) == NULL;
 +}
 +
 +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap) {
 +    soap_fault(soap);​
 +    if (soap->​fault == NULL)
 +        return NULL;
 +    if (soap->​version == 2 && soap->​fault->​SOAP_ENV__Code)
 +        return (const char**)(void*)&​soap->​fault->​SOAP_ENV__Code->​SOAP_ENV__Value;​
 +    return (const char**)(void*)&​soap->​fault->​faultcode;​
 +}
 +
 +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap) {
 +    soap_fault(soap);​
 +    if (soap->​fault == NULL)
 +        return NULL;
 +    if (soap->​version == 2 && soap->​fault->​SOAP_ENV__Code) {
 +        if (soap->​fault->​SOAP_ENV__Code->​SOAP_ENV__Subcode == NULL) {
 +            soap->​fault->​SOAP_ENV__Code->​SOAP_ENV__Subcode = soap_new_SOAP_ENV__Code(soap,​ -1);
 +            if (soap->​fault->​SOAP_ENV__Code->​SOAP_ENV__Subcode == NULL)
 +                return NULL;
 +        }
 +        return (const char**)(void*)&​soap->​fault->​SOAP_ENV__Code->​SOAP_ENV__Subcode->​SOAP_ENV__Value;​
 +    }
 +    return (const char**)(void*)&​soap->​fault->​faultcode;​
 +}
 +
 +SOAP_FMAC3 const char * SOAP_FMAC4 soap_fault_subcode(struct soap *soap) {
 +    const char **s = soap_faultsubcode(soap);​
 +    return s ? *s : NULL;
 +}
 +
 +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap) {
 +    soap_fault(soap);​
 +    if (soap->​fault == NULL)
 +        return NULL;
 +    if (soap->​version == 2 && soap->​fault->​SOAP_ENV__Reason)
 +        return (const char**)(void*)&​soap->​fault->​SOAP_ENV__Reason->​SOAP_ENV__Text;​
 +    return (const char**)(void*)&​soap->​fault->​faultstring;​
 +}
 +
 +SOAP_FMAC3 const char * SOAP_FMAC4 soap_fault_string(struct soap *soap) {
 +    const char **s = soap_faultstring(soap);​
 +    return s ? *s : NULL;
 +}
 +
 +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap) {
 +    soap_fault(soap);​
 +    if (soap->​fault == NULL)
 +        return NULL;
 +    if (soap->​version == 2) {
 +        if (soap->​fault->​SOAP_ENV__Detail == NULL)
 +            soap->​fault->​SOAP_ENV__Detail = soap_new_SOAP_ENV__Detail(soap,​ -1);
 +        return (const char**)(void*)&​soap->​fault->​SOAP_ENV__Detail->​__any;​
 +    }
 +    if (soap->​fault->​detail == NULL)
 +        soap->​fault->​detail = soap_new_SOAP_ENV__Detail(soap,​ -1);
 +    return (const char**)(void*)&​soap->​fault->​detail->​__any;​
 +}
 +
 +SOAP_FMAC3 const char * SOAP_FMAC4 soap_fault_detail(struct soap *soap) {
 +    const char **s = soap_faultdetail(soap);​
 +    return s ? *s : NULL;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOIDREF
 +SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap) {
 +    int t;
 +    if (soap->​version == 1) {
 +        for (;;) {
 +            if (!soap_getelement(soap,​ NULL, &t))
 +                if ((soap->​error && soap->​error != SOAP_TAG_MISMATCH) || soap_ignore_element(soap))
 +                    break;
 +        }
 +    }
 +    if (soap->​error == SOAP_NO_TAG || soap->​error == SOAP_EOF)
 +        soap->​error = SOAP_OK;
 +    return soap->​error;​
 +}
 +#endif
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, const char *tag, int *type) {
 +    (void)type;
 +    if (soap_peek_element(soap))
 +        return NULL;
 +#ifndef WITH_NOIDREF
 +    if (!*soap->​id || !(*type = soap_lookup_type(soap,​ soap->​id)))
 +        *type = soap_lookup_type(soap,​ soap->​href);​
 +    switch (*type) {
 +    case SOAP_TYPE_byte:​
 +        return soap_in_byte(soap,​ tag, NULL, "​xsd:​byte"​);​
 +    case SOAP_TYPE_int:​
 +        return soap_in_int(soap,​ tag, NULL, "​xsd:​int"​);​
 +    case SOAP_TYPE_h__hello:​
 +        return soap_in_h__hello(soap,​ tag, NULL, "​h:​hello"​);​
 +    case SOAP_TYPE_h__helloResponse:​
 +        return soap_in_h__helloResponse(soap,​ tag, NULL, "​h:​helloResponse"​);​
 +    case SOAP_TYPE__QName:​ {
 +        char **s;
 +        s = soap_in__QName(soap,​ tag, NULL, "​xsd:​QName"​);​
 +        return s ? *s : NULL;
 +    }
 +    case SOAP_TYPE_string:​ {
 +        char **s;
 +        s = soap_in_string(soap,​ tag, NULL, "​xsd:​string"​);​
 +        return s ? *s : NULL;
 +    }
 +    default:
 +#else
 +    *type = 0;
 +#endif
 +        {
 +            const char *t = soap->​type;​
 +            if (!*t)
 +                t = soap->​tag;​
 +            if (!soap_match_tag(soap,​ t, "​xsd:​byte"​)) {
 +                *type = SOAP_TYPE_byte;​
 +                return soap_in_byte(soap,​ tag, NULL, NULL);
 +            }
 +            if (!soap_match_tag(soap,​ t, "​xsd:​int"​)) {
 +                *type = SOAP_TYPE_int;​
 +                return soap_in_int(soap,​ tag, NULL, NULL);
 +            }
 +            if (!soap_match_tag(soap,​ t, "​h:​hello"​)) {
 +                *type = SOAP_TYPE_h__hello;​
 +                return soap_in_h__hello(soap,​ tag, NULL, NULL);
 +            }
 +            if (!soap_match_tag(soap,​ t, "​h:​helloResponse"​)) {
 +                *type = SOAP_TYPE_h__helloResponse;​
 +                return soap_in_h__helloResponse(soap,​ tag, NULL, NULL);
 +            }
 +            if (!soap_match_tag(soap,​ t, "​xsd:​QName"​)) {
 +                char **s;
 +                *type = SOAP_TYPE__QName;​
 +                s = soap_in__QName(soap,​ tag, NULL, NULL);
 +                return s ? *s : NULL;
 +            }
 +            if (!soap_match_tag(soap,​ t, "​xsd:​string"​)) {
 +                char **s;
 +                *type = SOAP_TYPE_string;​
 +                s = soap_in_string(soap,​ tag, NULL, NULL);
 +                return s ? *s : NULL;
 +            }
 +            t = soap->​tag;​
 +#ifndef WITH_NOIDREF
 +        }
 +#endif
 +    }
 +    soap->​error = SOAP_TAG_MISMATCH;​
 +    return NULL;
 +}
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap) {
 +    if (!soap_peek_element(soap)) {
 +        int t;
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Unexpected element '​%s'​ in input (level = %u, %d)\n",​ soap->​tag,​ soap->​level,​ soap->​body));​
 +        if (soap->​mustUnderstand && !soap->​other && !soap->​fignore)
 +            return soap->​error = SOAP_MUSTUNDERSTAND;​
 +        if (((soap->​mode & SOAP_XML_STRICT) && !soap->​fignore && soap->​part != SOAP_IN_HEADER) || !soap_match_tag(soap,​ soap->​tag,​ "​SOAP-ENV:"​)) {
 +            DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​REJECTING element '​%s'​\n",​ soap->​tag));​
 +            return soap->​error = SOAP_TAG_MISMATCH;​
 +        }
 +        if (!*soap->​id || !soap_getelement(soap,​ NULL, &t)) {
 +            soap->​peeked = 0;
 +            if (soap->​fignore)
 +                soap->​error = soap->​fignore(soap,​ soap->​tag);​
 +            else
 +                soap->​error = SOAP_OK;
 +            DBGLOG(TEST,​ if (!soap->​error) SOAP_MESSAGE(fdebug,​ "​IGNORING element '​%s'​\n",​ soap->​tag));​
 +            if (!soap->​error && soap->​body && soap_ignore(soap))
 +                return soap->​error;​
 +        }
 +    }
 +    return soap->​error;​
 +}
 +
 +#ifndef WITH_NOIDREF
 +SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap) {
 +    int i;
 +    struct soap_plist *pp;
 +    if (soap->​version == 1 && soap->​encodingStyle && !(soap->​mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
 +        for (i = 0; i < SOAP_PTRHASH;​ i++)
 +            for (pp = soap->​pht[i];​ pp; pp = pp->​next)
 +                if (pp->​mark1 == 2 || pp->​mark2 == 2)
 +                    if (soap_putelement(soap,​ pp->ptr, SOAP_MULTIREFTAG,​ pp->id, pp->​type))
 +                        return soap->​error;​
 +    return SOAP_OK;
 +}
 +#endif
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type) {
 +    (void)tag;
 +    switch (type) {
 +    case SOAP_TYPE_byte:​
 +        return soap_out_byte(soap,​ tag, id, (const char *)ptr, "​xsd:​byte"​);​
 +    case SOAP_TYPE_int:​
 +        return soap_out_int(soap,​ tag, id, (const int *)ptr, "​xsd:​int"​);​
 +    case SOAP_TYPE_h__hello:​
 +        return soap_out_h__hello(soap,​ tag, id, (const struct h__hello *)ptr, "​h:​hello"​);​
 +    case SOAP_TYPE_h__helloResponse:​
 +        return soap_out_h__helloResponse(soap,​ tag, id, (const struct h__helloResponse *)ptr, "​h:​helloResponse"​);​
 +    case SOAP_TYPE__QName:​
 +        return soap_out_string(soap,​ tag, id, (char*const*)(void*)&​ptr,​ "​xsd:​QName"​);​
 +    case SOAP_TYPE_string:​
 +        return soap_out_string(soap,​ tag, id, (char*const*)(void*)&​ptr,​ "​xsd:​string"​);​
 +    case 0:
 +        return SOAP_OK;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_putelement '​%s'​ failed for type %d in soapC.cpp\n",​ tag ? tag : "",​ type));
 +    return soap_element_empty(soap,​ tag); /* unknown type to serialize */
 +}
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +#ifndef WITH_NOIDREF
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type) {
 +    (void)soap;
 +    (void)ptr;
 +    (void)type; /* appease -Wall -Werror */
 +    switch (type) {
 +    case SOAP_TYPE_h__hello:​
 +        soap_serialize_h__hello(soap,​ (const struct h__hello *)ptr);
 +        break;
 +    case SOAP_TYPE_h__helloResponse:​
 +        soap_serialize_h__helloResponse(soap,​ (const struct h__helloResponse *)ptr);
 +        break;
 +    case SOAP_TYPE__QName:​
 +        soap_serialize_string(soap,​ (char*const*)(void*)&​ptr);​
 +        break;
 +    case SOAP_TYPE_string:​
 +        soap_serialize_string(soap,​ (char*const*)(void*)&​ptr);​
 +        break;
 +    }
 +}
 +#ifdef __cplusplus
 +}
 +#endif
 +#endif
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +
 +SOAP_FMAC3 void * SOAP_FMAC4 soap_dupelement(struct soap *soap, const void *ptr, int type) {
 +    (void)soap;
 +    (void)ptr;
 +    (void)type; /* appease -Wall -Werror */
 +    return NULL;
 +}
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_delelement(const void *ptr, int type) {
 +    (void)ptr;
 +    (void)type; /* appease -Wall -Werror */
 +}
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap *soap, int t, const char *type, const char *arrayType, size_t *n) {
 +    (void)type;
 +    switch (t) {
 +    case SOAP_TYPE_h__helloResponse:​
 +        return (void*)soap_instantiate_h__helloResponse(soap,​ -1, type, arrayType, n);
 +    case SOAP_TYPE_h__hello:​
 +        return (void*)soap_instantiate_h__hello(soap,​ -1, type, arrayType, n);
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Header:​
 +        return (void*)soap_instantiate_SOAP_ENV__Header(soap,​ -1, type, arrayType, n);
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Code:​
 +        return (void*)soap_instantiate_SOAP_ENV__Code(soap,​ -1, type, arrayType, n);
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Detail:​
 +        return (void*)soap_instantiate_SOAP_ENV__Detail(soap,​ -1, type, arrayType, n);
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Reason:​
 +        return (void*)soap_instantiate_SOAP_ENV__Reason(soap,​ -1, type, arrayType, n);
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Fault:​
 +        return (void*)soap_instantiate_SOAP_ENV__Fault(soap,​ -1, type, arrayType, n);
 +#endif
 +    }
 +    return NULL;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap *soap, struct soap_clist *p) {
 +    (void)soap; /* appease -Wall -Werror */
 +    if (!p->​ptr)
 +        return SOAP_OK;
 +    switch (p->​type) {
 +    case SOAP_TYPE_h__helloResponse:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct h__helloResponse*>​(p->​ptr),​ struct h__helloResponse);​
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct h__helloResponse*>​(p->​ptr),​ struct h__helloResponse);​
 +        break;
 +    case SOAP_TYPE_h__hello:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct h__hello*>​(p->​ptr),​ struct h__hello);
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct h__hello*>​(p->​ptr),​ struct h__hello);
 +        break;
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Header:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct SOAP_ENV__Header*>​(p->​ptr),​ struct SOAP_ENV__Header);​
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct SOAP_ENV__Header*>​(p->​ptr),​ struct SOAP_ENV__Header);​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Code:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct SOAP_ENV__Code*>​(p->​ptr),​ struct SOAP_ENV__Code);​
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct SOAP_ENV__Code*>​(p->​ptr),​ struct SOAP_ENV__Code);​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Detail:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct SOAP_ENV__Detail*>​(p->​ptr),​ struct SOAP_ENV__Detail);​
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct SOAP_ENV__Detail*>​(p->​ptr),​ struct SOAP_ENV__Detail);​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Reason:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct SOAP_ENV__Reason*>​(p->​ptr),​ struct SOAP_ENV__Reason);​
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct SOAP_ENV__Reason*>​(p->​ptr),​ struct SOAP_ENV__Reason);​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Fault:​
 +        if (p->size < 0)
 +            SOAP_DELETE(soap,​ static_cast<​struct SOAP_ENV__Fault*>​(p->​ptr),​ struct SOAP_ENV__Fault);​
 +        else
 +            SOAP_DELETE_ARRAY(soap,​ static_cast<​struct SOAP_ENV__Fault*>​(p->​ptr),​ struct SOAP_ENV__Fault);​
 +        break;
 +#endif
 +    default:
 +        return SOAP_ERR;
 +    }
 +    return SOAP_OK;
 +}
 +
 +#ifdef WIN32
 +#pragma warning(push)
 +// do not warn on switch w/o cases
 +#pragma warning(disable:​4065)
 +#endif
 +SOAP_FMAC3 int SOAP_FMAC4 soap_fbase(int t, int b) {
 +    (void)t;
 +    (void)b; /* appease -Wall -Werror */
 +    return 0;
 +}
 +#ifdef WIN32
 +#pragma warning(pop)
 +#endif
 +
 +#ifndef WITH_NOIDREF
 +#ifdef WIN32
 +#pragma warning(push)
 +// do not warn on switch w/o cases
 +#pragma warning(disable:​4065)
 +#endif
 +SOAP_FMAC3 void SOAP_FMAC4 soap_finsert(struct soap *soap, int t, int tt, void *p, size_t index, const void *q, void **x) {
 +    (void)soap;
 +    (void)t;
 +    (void)p;
 +    (void)index;​
 +    (void)q;
 +    (void)x; /* appease -Wall -Werror */
 +    switch (tt) {
 +    case SOAP_TYPE_h__helloResponse:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct h__helloResponse type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct h__helloResponse*)p = *(struct h__helloResponse*)q;​
 +        break;
 +    case SOAP_TYPE_h__hello:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct h__hello type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct h__hello*)p = *(struct h__hello*)q;​
 +        break;
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Header:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct SOAP_ENV__Header type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q;​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Code:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct SOAP_ENV__Code type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q;​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Detail:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct SOAP_ENV__Detail type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q;​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Reason:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct SOAP_ENV__Reason type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q;​
 +        break;
 +#endif
 +#ifndef WITH_NOGLOBAL
 +    case SOAP_TYPE_SOAP_ENV__Fault:​
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Copy struct SOAP_ENV__Fault type=%d location=%p object=%p\n",​ t, p, q));
 +        *(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q;​
 +        break;
 +#endif
 +    default:
 +        DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "Could not insert type=%d in %d\n", t, tt));
 +    }
 +}
 +#ifdef WIN32
 +#pragma warning(pop)
 +#endif
 +#endif
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type) {
 +    return soap_outbyte(soap,​ tag, id, a, type, SOAP_TYPE_byte);​
 +}
 +
 +SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type) {
 +    a = soap_inbyte(soap,​ tag, a, type, SOAP_TYPE_byte);​
 +    return a;
 +}
 +
 +SOAP_FMAC3 char * SOAP_FMAC4 soap_new_byte(struct soap *soap, int n) {
 +    char *a = static_cast<​char *>​(soap_malloc(soap,​ (n = (n < 0 ? 1 : n)) * sizeof(char)));​
 +    for (char *p = a; p && n--; ++p)
 +        soap_default_byte(soap,​ p);
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type) {
 +    if (soap_out_byte(soap,​ tag ? tag : "​byte",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type) {
 +    if ((p = soap_in_byte(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type) {
 +    return soap_outint(soap,​ tag, id, a, type, SOAP_TYPE_int);​
 +}
 +
 +SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type) {
 +    a = soap_inint(soap,​ tag, a, type, SOAP_TYPE_int);​
 +    return a;
 +}
 +
 +SOAP_FMAC3 int * SOAP_FMAC4 soap_new_int(struct soap *soap, int n) {
 +    int *a = static_cast<​int *>​(soap_malloc(soap,​ (n = (n < 0 ? 1 : n)) * sizeof(int)));​
 +    for (int *p = a; p && n--; ++p)
 +        soap_default_int(soap,​ p);
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type) {
 +    if (soap_out_int(soap,​ tag ? tag : "​int",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type) {
 +    if ((p = soap_in_int(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +    soap_default__QName(soap,​ &​a->​faultcode);​
 +    soap_default_string(soap,​ &​a->​faultstring);​
 +    soap_default_string(soap,​ &​a->​faultactor);​
 +    a->​detail = NULL;
 +    a->​SOAP_ENV__Code = NULL;
 +    a->​SOAP_ENV__Reason = NULL;
 +    soap_default_string(soap,​ &​a->​SOAP_ENV__Node);​
 +    soap_default_string(soap,​ &​a->​SOAP_ENV__Role);​
 +    a->​SOAP_ENV__Detail = NULL;
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    soap_serialize__QName(soap,​ (char*const*)&​a->​faultcode);​
 +    soap_serialize_string(soap,​ (char*const*)&​a->​faultstring);​
 +    soap_serialize_string(soap,​ (char*const*)&​a->​faultactor);​
 +    soap_serialize_PointerToSOAP_ENV__Detail(soap,​ &​a->​detail);​
 +    soap_serialize_PointerToSOAP_ENV__Code(soap,​ &​a->​SOAP_ENV__Code);​
 +    soap_serialize_PointerToSOAP_ENV__Reason(soap,​ &​a->​SOAP_ENV__Reason);​
 +    soap_serialize_string(soap,​ (char*const*)&​a->​SOAP_ENV__Node);​
 +    soap_serialize_string(soap,​ (char*const*)&​a->​SOAP_ENV__Role);​
 +    soap_serialize_PointerToSOAP_ENV__Detail(soap,​ &​a->​SOAP_ENV__Detail);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Fault *a, const char *type) {
 +    const char *soap_tmp_faultcode;​
 +    soap_tmp_faultcode = soap_QName2s(soap,​ a->​faultcode);​
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_SOAP_ENV__Fault),​ type))
 +        return soap->​error;​
 +    if (soap_out__QName(soap,​ "​faultcode",​ -1, (char*const*)(void*)&​soap_tmp_faultcode,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_string(soap,​ "​faultstring",​ -1, (char*const*)&​a->​faultstring,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_string(soap,​ "​faultactor",​ -1, (char*const*)&​a->​faultactor,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_PointerToSOAP_ENV__Detail(soap,​ "​detail",​ -1, &​a->​detail,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_PointerToSOAP_ENV__Code(soap,​ "​SOAP-ENV:​Code",​ -1, &​a->​SOAP_ENV__Code,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_PointerToSOAP_ENV__Reason(soap,​ "​SOAP-ENV:​Reason",​ -1, &​a->​SOAP_ENV__Reason,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_string(soap,​ "​SOAP-ENV:​Node",​ -1, (char*const*)&​a->​SOAP_ENV__Node,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_string(soap,​ "​SOAP-ENV:​Role",​ -1, (char*const*)&​a->​SOAP_ENV__Role,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_PointerToSOAP_ENV__Detail(soap,​ "​SOAP-ENV:​Detail",​ -1, &​a->​SOAP_ENV__Detail,​ ""​))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap *soap, const char *tag, struct SOAP_ENV__Fault *a, const char *type) {
 +    size_t soap_flag_faultcode = 1;
 +    size_t soap_flag_faultstring = 1;
 +    size_t soap_flag_faultactor = 1;
 +    size_t soap_flag_detail = 1;
 +    size_t soap_flag_SOAP_ENV__Code = 1;
 +    size_t soap_flag_SOAP_ENV__Reason = 1;
 +    size_t soap_flag_SOAP_ENV__Node = 1;
 +    size_t soap_flag_SOAP_ENV__Role = 1;
 +    size_t soap_flag_SOAP_ENV__Detail = 1;
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct SOAP_ENV__Fault*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_SOAP_ENV__Fault,​ sizeof(struct SOAP_ENV__Fault),​ NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_SOAP_ENV__Fault(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap_flag_faultcode && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in__QName(soap,​ "​faultcode",​ (char**)&​a->​faultcode,​ "​xsd:​QName"​)) {
 +                    soap_flag_faultcode--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_faultstring && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in_string(soap,​ "​faultstring",​ (char**)&​a->​faultstring,​ "​xsd:​string"​)) {
 +                    soap_flag_faultstring--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_faultactor && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in_string(soap,​ "​faultactor",​ (char**)&​a->​faultactor,​ "​xsd:​string"​)) {
 +                    soap_flag_faultactor--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_detail && soap->​error == SOAP_TAG_MISMATCH) {
 +                if (soap_in_PointerToSOAP_ENV__Detail(soap,​ "​detail",​ &​a->​detail,​ ""​)) {
 +                    soap_flag_detail--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_SOAP_ENV__Code && soap->​error == SOAP_TAG_MISMATCH) {
 +                if (soap_in_PointerToSOAP_ENV__Code(soap,​ "​SOAP-ENV:​Code",​ &​a->​SOAP_ENV__Code,​ ""​)) {
 +                    soap_flag_SOAP_ENV__Code--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_SOAP_ENV__Reason && soap->​error == SOAP_TAG_MISMATCH) {
 +                if (soap_in_PointerToSOAP_ENV__Reason(soap,​ "​SOAP-ENV:​Reason",​ &​a->​SOAP_ENV__Reason,​ ""​)) {
 +                    soap_flag_SOAP_ENV__Reason--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_SOAP_ENV__Node && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in_string(soap,​ "​SOAP-ENV:​Node",​ (char**)&​a->​SOAP_ENV__Node,​ "​xsd:​string"​)) {
 +                    soap_flag_SOAP_ENV__Node--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_SOAP_ENV__Role && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in_string(soap,​ "​SOAP-ENV:​Role",​ (char**)&​a->​SOAP_ENV__Role,​ "​xsd:​string"​)) {
 +                    soap_flag_SOAP_ENV__Role--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_SOAP_ENV__Detail && soap->​error == SOAP_TAG_MISMATCH) {
 +                if (soap_in_PointerToSOAP_ENV__Detail(soap,​ "​SOAP-ENV:​Detail",​ &​a->​SOAP_ENV__Detail,​ ""​)) {
 +                    soap_flag_SOAP_ENV__Detail--;​
 +                    continue;
 +                }
 +            }
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Fault *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_SOAP_ENV__Fault,​ SOAP_TYPE_SOAP_ENV__Fault,​ sizeof(struct SOAP_ENV__Fault),​ 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_SOAP_ENV__Fault(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct SOAP_ENV__Fault *p;
 +    size_t k = sizeof(struct SOAP_ENV__Fault);​
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_SOAP_ENV__Fault,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct SOAP_ENV__Fault);​
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct SOAP_ENV__Fault,​ n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct SOAP_ENV__Fault location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a, const char *tag, const char *type) {
 +    if (soap_out_SOAP_ENV__Fault(soap,​ tag ? tag : "​SOAP-ENV:​Fault",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p, const char *tag, const char *type) {
 +    if ((p = soap_in_SOAP_ENV__Fault(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +    soap_default_string(soap,​ &​a->​SOAP_ENV__Text);​
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    soap_serialize_string(soap,​ (char*const*)&​a->​SOAP_ENV__Text);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Reason *a, const char *type) {
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_SOAP_ENV__Reason),​ type))
 +        return soap->​error;​
 +    if (soap->​lang)
 +        soap_set_attr(soap,​ "​xml:​lang",​ soap->​lang,​ 1);
 +    if (soap_out_string(soap,​ "​SOAP-ENV:​Text",​ -1, (char*const*)&​a->​SOAP_ENV__Text,​ ""​))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason *a, const char *type) {
 +    size_t soap_flag_SOAP_ENV__Text = 1;
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct SOAP_ENV__Reason*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_SOAP_ENV__Reason,​ sizeof(struct SOAP_ENV__Reason),​ NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_SOAP_ENV__Reason(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap_flag_SOAP_ENV__Text && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in_string(soap,​ "​SOAP-ENV:​Text",​ (char**)&​a->​SOAP_ENV__Text,​ "​xsd:​string"​)) {
 +                    soap_flag_SOAP_ENV__Text--;​
 +                    continue;
 +                }
 +            }
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Reason *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_SOAP_ENV__Reason,​ SOAP_TYPE_SOAP_ENV__Reason,​ sizeof(struct SOAP_ENV__Reason),​ 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_SOAP_ENV__Reason(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct SOAP_ENV__Reason *p;
 +    size_t k = sizeof(struct SOAP_ENV__Reason);​
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_SOAP_ENV__Reason,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct SOAP_ENV__Reason);​
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct SOAP_ENV__Reason,​ n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct SOAP_ENV__Reason location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a, const char *tag, const char *type) {
 +    if (soap_out_SOAP_ENV__Reason(soap,​ tag ? tag : "​SOAP-ENV:​Reason",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p, const char *tag, const char *type) {
 +    if ((p = soap_in_SOAP_ENV__Reason(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +    a->__any = NULL;
 +    a->​__type = 0;
 +    a->fault = NULL;
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    soap_markelement(soap,​ a->​fault,​ a->​__type);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Detail *a, const char *type) {
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_SOAP_ENV__Detail),​ type))
 +        return soap->​error;​
 +    if (soap_outliteral(soap,​ "​-any",​ (char*const*)&​a->​__any,​ NULL))
 +        return soap->​error;​
 +    if (soap_putelement(soap,​ a->​fault,​ "​fault",​ -1, a->​__type))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail *a, const char *type) {
 +    size_t soap_flag___any = 1;
 +    size_t soap_flag_fault = 1;
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct SOAP_ENV__Detail*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_SOAP_ENV__Detail,​ sizeof(struct SOAP_ENV__Detail),​ NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_SOAP_ENV__Detail(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap_flag_fault && soap->​error == SOAP_TAG_MISMATCH) {
 +                if ((a->​fault = soap_getelement(soap,​ "​fault",​ &​a->​__type))) {
 +                    soap_flag_fault = 0;
 +                    continue;
 +                }
 +            }
 +            if (soap_flag___any && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_inliteral(soap,​ "​-any",​ (char**)&​a->​__any)) {
 +                    soap_flag___any--;​
 +                    continue;
 +                }
 +            }
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Detail *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_SOAP_ENV__Detail,​ SOAP_TYPE_SOAP_ENV__Detail,​ sizeof(struct SOAP_ENV__Detail),​ 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_SOAP_ENV__Detail(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct SOAP_ENV__Detail *p;
 +    size_t k = sizeof(struct SOAP_ENV__Detail);​
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_SOAP_ENV__Detail,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct SOAP_ENV__Detail);​
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct SOAP_ENV__Detail,​ n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct SOAP_ENV__Detail location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a, const char *tag, const char *type) {
 +    if (soap_out_SOAP_ENV__Detail(soap,​ tag ? tag : "​SOAP-ENV:​Detail",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p, const char *tag, const char *type) {
 +    if ((p = soap_in_SOAP_ENV__Detail(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +    soap_default__QName(soap,​ &​a->​SOAP_ENV__Value);​
 +    a->​SOAP_ENV__Subcode = NULL;
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    soap_serialize__QName(soap,​ (char*const*)&​a->​SOAP_ENV__Value);​
 +    soap_serialize_PointerToSOAP_ENV__Code(soap,​ &​a->​SOAP_ENV__Subcode);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Code *a, const char *type) {
 +    const char *soap_tmp_SOAP_ENV__Value;​
 +    soap_tmp_SOAP_ENV__Value = soap_QName2s(soap,​ a->​SOAP_ENV__Value);​
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_SOAP_ENV__Code),​ type))
 +        return soap->​error;​
 +    if (soap_out__QName(soap,​ "​SOAP-ENV:​Value",​ -1, (char*const*)(void*)&​soap_tmp_SOAP_ENV__Value,​ ""​))
 +        return soap->​error;​
 +    if (soap_out_PointerToSOAP_ENV__Code(soap,​ "​SOAP-ENV:​Subcode",​ -1, &​a->​SOAP_ENV__Subcode,​ ""​))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code *a, const char *type) {
 +    size_t soap_flag_SOAP_ENV__Value = 1;
 +    size_t soap_flag_SOAP_ENV__Subcode = 1;
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct SOAP_ENV__Code*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_SOAP_ENV__Code,​ sizeof(struct SOAP_ENV__Code),​ NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_SOAP_ENV__Code(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap_flag_SOAP_ENV__Value && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in__QName(soap,​ "​SOAP-ENV:​Value",​ (char**)&​a->​SOAP_ENV__Value,​ "​xsd:​QName"​)) {
 +                    soap_flag_SOAP_ENV__Value--;​
 +                    continue;
 +                }
 +            }
 +            if (soap_flag_SOAP_ENV__Subcode && soap->​error == SOAP_TAG_MISMATCH) {
 +                if (soap_in_PointerToSOAP_ENV__Code(soap,​ "​SOAP-ENV:​Subcode",​ &​a->​SOAP_ENV__Subcode,​ ""​)) {
 +                    soap_flag_SOAP_ENV__Subcode--;​
 +                    continue;
 +                }
 +            }
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Code *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_SOAP_ENV__Code,​ SOAP_TYPE_SOAP_ENV__Code,​ sizeof(struct SOAP_ENV__Code),​ 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_SOAP_ENV__Code(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct SOAP_ENV__Code *p;
 +    size_t k = sizeof(struct SOAP_ENV__Code);​
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_SOAP_ENV__Code,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct SOAP_ENV__Code);​
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct SOAP_ENV__Code,​ n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct SOAP_ENV__Code location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a, const char *tag, const char *type) {
 +    if (soap_out_SOAP_ENV__Code(soap,​ tag ? tag : "​SOAP-ENV:​Code",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p, const char *tag, const char *type) {
 +    if ((p = soap_in_SOAP_ENV__Code(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Header *a, const char *type) {
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_SOAP_ENV__Header),​ type))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap *soap, const char *tag, struct SOAP_ENV__Header *a, const char *type) {
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct SOAP_ENV__Header*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_SOAP_ENV__Header,​ sizeof(struct SOAP_ENV__Header),​ NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_SOAP_ENV__Header(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Header *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_SOAP_ENV__Header,​ SOAP_TYPE_SOAP_ENV__Header,​ sizeof(struct SOAP_ENV__Header),​ 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_SOAP_ENV__Header(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct SOAP_ENV__Header *p;
 +    size_t k = sizeof(struct SOAP_ENV__Header);​
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_SOAP_ENV__Header,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct SOAP_ENV__Header);​
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct SOAP_ENV__Header,​ n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct SOAP_ENV__Header location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a, const char *tag, const char *type) {
 +    if (soap_out_SOAP_ENV__Header(soap,​ tag ? tag : "​SOAP-ENV:​Header",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p, const char *tag, const char *type) {
 +    if ((p = soap_in_SOAP_ENV__Header(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_h__hello(struct soap *soap, struct h__hello *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_h__hello(struct soap *soap, const struct h__hello *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_h__hello(struct soap *soap, const char *tag, int id, const struct h__hello *a, const char *type) {
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_h__hello),​ type))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct h__hello * SOAP_FMAC4 soap_in_h__hello(struct soap *soap, const char *tag, struct h__hello *a, const char *type) {
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct h__hello*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_h__hello,​ sizeof(struct h__hello), NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_h__hello(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    } else {
 +        a = (struct h__hello *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_h__hello,​ SOAP_TYPE_h__hello,​ sizeof(struct h__hello), 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct h__hello * SOAP_FMAC2 soap_instantiate_h__hello(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_h__hello(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct h__hello *p;
 +    size_t k = sizeof(struct h__hello);
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_h__hello,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct h__hello);
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct h__hello, n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct h__hello location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_h__hello(struct soap *soap, const struct h__hello *a, const char *tag, const char *type) {
 +    if (soap_out_h__hello(soap,​ tag ? tag : "​h:​hello",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct h__hello * SOAP_FMAC4 soap_get_h__hello(struct soap *soap, struct h__hello *p, const char *tag, const char *type) {
 +    if ((p = soap_in_h__hello(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_h__helloResponse(struct soap *soap, struct h__helloResponse *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +    soap_default_string(soap,​ &​a->​_param_1);​
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_h__helloResponse(struct soap *soap, const struct h__helloResponse *a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    soap_serialize_string(soap,​ (char*const*)&​a->​_param_1);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_h__helloResponse(struct soap *soap, const char *tag, int id, const struct h__helloResponse *a, const char *type) {
 +    (void)soap;
 +    (void)tag;
 +    (void)id;
 +    (void)a;
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_out(soap,​ tag, soap_embedded_id(soap,​ id, a, SOAP_TYPE_h__helloResponse),​ type))
 +        return soap->​error;​
 +    if (!a->​_param_1) {
 +        if (soap_element_empty(soap,​ "​param-1"​))
 +            return soap->​error;​
 +    } else if (soap_out_string(soap,​ "​param-1",​ -1, (char*const*)&​a->​_param_1,​ ""​))
 +        return soap->​error;​
 +    return soap_element_end_out(soap,​ tag);
 +}
 +
 +SOAP_FMAC3 struct h__helloResponse * SOAP_FMAC4 soap_in_h__helloResponse(struct soap *soap, const char *tag, struct h__helloResponse *a, const char *type) {
 +    size_t soap_flag__param_1 = 1;
 +    if (soap_element_begin_in(soap,​ tag, 0, NULL))
 +        return NULL;
 +    (void)type; /* appease -Wall -Werror */
 +    a = (struct h__helloResponse*)soap_id_enter(soap,​ soap->​id,​ a, SOAP_TYPE_h__helloResponse,​ sizeof(struct h__helloResponse),​ NULL, NULL, NULL, NULL);
 +    if (!a)
 +        return NULL;
 +    soap_default_h__helloResponse(soap,​ a);
 +    if (soap->​body && *soap->​href != '#'​) {
 +        for (;;) {
 +            soap->​error = SOAP_TAG_MISMATCH;​
 +            if (soap_flag__param_1 && (soap->​error == SOAP_TAG_MISMATCH || soap->​error == SOAP_NO_TAG)) {
 +                if (soap_in_string(soap,​ NULL, (char**)&​a->​_param_1,​ "​xsd:​string"​)) {
 +                    soap_flag__param_1--;​
 +                    continue;
 +                }
 +            }
 +            if (soap->​error == SOAP_TAG_MISMATCH)
 +                soap->​error = soap_ignore_element(soap);​
 +            if (soap->​error == SOAP_NO_TAG)
 +                break;
 +            if (soap->​error)
 +                return NULL;
 +        }
 +        if (soap_element_end_in(soap,​ tag))
 +            return NULL;
 +        if ((soap->​mode & SOAP_XML_STRICT) && (!a->​_param_1)) {
 +            soap->​error = SOAP_OCCURS;​
 +            return NULL;
 +        }
 +    } else if ((soap->​mode & SOAP_XML_STRICT) && *soap->​href != '#'​) {
 +        soap->​error = SOAP_OCCURS;​
 +        return NULL;
 +    } else {
 +        a = (struct h__helloResponse *)soap_id_forward(soap,​ soap->​href,​ (void*)a, 0, SOAP_TYPE_h__helloResponse,​ SOAP_TYPE_h__helloResponse,​ sizeof(struct h__helloResponse),​ 0, soap_finsert,​ NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC1 struct h__helloResponse * SOAP_FMAC2 soap_instantiate_h__helloResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) {
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​soap_instantiate_h__helloResponse(%p,​ %d, %s, %s)\n",​ (void*)soap,​ n, type?​type:"",​ arrayType?​arrayType:""​));​
 +    (void)type;
 +    (void)arrayType;​ /* appease -Wall -Werror */
 +    struct h__helloResponse *p;
 +    size_t k = sizeof(struct h__helloResponse);​
 +    struct soap_clist *cp = soap_link(soap,​ SOAP_TYPE_h__helloResponse,​ n, soap_fdelete);​
 +    if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
 +        return NULL;
 +    if (n < 0) {
 +        p = SOAP_NEW(soap,​ struct h__helloResponse);​
 +    } else {
 +        p = SOAP_NEW_ARRAY(soap,​ struct h__helloResponse,​ n);
 +        k *= n;
 +    }
 +    DBGLOG(TEST,​ SOAP_MESSAGE(fdebug,​ "​Instantiated struct h__helloResponse location=%p n=%d\n",​ (void*)p, n));
 +    if (size)
 +        *size = k;
 +    if (!p)
 +        soap->​error = SOAP_EOM;
 +    else if (cp)
 +        cp->ptr = (void*)p;
 +    return p;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_h__helloResponse(struct soap *soap, const struct h__helloResponse *a, const char *tag, const char *type) {
 +    if (soap_out_h__helloResponse(soap,​ tag ? tag : "​h:​helloResponse",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct h__helloResponse * SOAP_FMAC4 soap_get_h__helloResponse(struct soap *soap, struct h__helloResponse *p, const char *tag, const char *type) {
 +    if ((p = soap_in_h__helloResponse(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    if (!soap_reference(soap,​ *a, SOAP_TYPE_SOAP_ENV__Reason))
 +        soap_serialize_SOAP_ENV__Reason(soap,​ *a);
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Reason *const*a, const char *type) {
 +    id = soap_element_id(soap,​ tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason,​ NULL);
 +    if (id < 0)
 +        return soap->​error;​
 +    return soap_out_SOAP_ENV__Reason(soap,​ tag, id, *a, type);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason **a, const char *type) {
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_in(soap,​ tag, 1, NULL))
 +        return NULL;
 +    if (!a)
 +        if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap,​ sizeof(struct SOAP_ENV__Reason *))))
 +            return NULL;
 +    *a = NULL;
 +    if (!soap->​null && *soap->​href != '#'​) {
 +        soap_revert(soap);​
 +        if (!(*a = soap_in_SOAP_ENV__Reason(soap,​ tag, *a, type)))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap,​ soap->​href,​ (void**)a, SOAP_TYPE_SOAP_ENV__Reason,​ sizeof(struct SOAP_ENV__Reason),​ 0, NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a, const char *tag, const char *type) {
 +    if (soap_out_PointerToSOAP_ENV__Reason(soap,​ tag ? tag : "​SOAP-ENV:​Reason",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason **p, const char *tag, const char *type) {
 +    if ((p = soap_in_PointerToSOAP_ENV__Reason(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    if (!soap_reference(soap,​ *a, SOAP_TYPE_SOAP_ENV__Detail))
 +        soap_serialize_SOAP_ENV__Detail(soap,​ *a);
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Detail *const*a, const char *type) {
 +    id = soap_element_id(soap,​ tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail,​ NULL);
 +    if (id < 0)
 +        return soap->​error;​
 +    return soap_out_SOAP_ENV__Detail(soap,​ tag, id, *a, type);
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail **a, const char *type) {
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_in(soap,​ tag, 1, NULL))
 +        return NULL;
 +    if (!a)
 +        if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap,​ sizeof(struct SOAP_ENV__Detail *))))
 +            return NULL;
 +    *a = NULL;
 +    if (!soap->​null && *soap->​href != '#'​) {
 +        soap_revert(soap);​
 +        if (!(*a = soap_in_SOAP_ENV__Detail(soap,​ tag, *a, type)))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap,​ soap->​href,​ (void**)a, SOAP_TYPE_SOAP_ENV__Detail,​ sizeof(struct SOAP_ENV__Detail),​ 0, NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a, const char *tag, const char *type) {
 +    if (soap_out_PointerToSOAP_ENV__Detail(soap,​ tag ? tag : "​SOAP-ENV:​Detail",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail **p, const char *tag, const char *type) {
 +    if ((p = soap_in_PointerToSOAP_ENV__Detail(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    if (!soap_reference(soap,​ *a, SOAP_TYPE_SOAP_ENV__Code))
 +        soap_serialize_SOAP_ENV__Code(soap,​ *a);
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Code *const*a, const char *type) {
 +    char *mark;
 +    id = soap_element_id(soap,​ tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code,​ &mark);
 +    if (id < 0)
 +        return soap->​error;​
 +    (void)soap_out_SOAP_ENV__Code(soap,​ tag, id, *a, type);
 +    soap_unmark(soap,​ mark);
 +    return soap->​error;​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code **a, const char *type) {
 +    (void)type; /* appease -Wall -Werror */
 +    if (soap_element_begin_in(soap,​ tag, 1, NULL))
 +        return NULL;
 +    if (!a)
 +        if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap,​ sizeof(struct SOAP_ENV__Code *))))
 +            return NULL;
 +    *a = NULL;
 +    if (!soap->​null && *soap->​href != '#'​) {
 +        soap_revert(soap);​
 +        if (!(*a = soap_in_SOAP_ENV__Code(soap,​ tag, *a, type)))
 +            return NULL;
 +    } else {
 +        a = (struct SOAP_ENV__Code **)soap_id_lookup(soap,​ soap->​href,​ (void**)a, SOAP_TYPE_SOAP_ENV__Code,​ sizeof(struct SOAP_ENV__Code),​ 0, NULL);
 +        if (soap->​body && soap_element_end_in(soap,​ tag))
 +            return NULL;
 +    }
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a, const char *tag, const char *type) {
 +    if (soap_out_PointerToSOAP_ENV__Code(soap,​ tag ? tag : "​SOAP-ENV:​Code",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **p, const char *tag, const char *type) {
 +    if ((p = soap_in_PointerToSOAP_ENV__Code(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#endif
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    (void)soap_reference(soap,​ *a, SOAP_TYPE__QName);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type) {
 +    return soap_outstring(soap,​ tag, id, a, type, SOAP_TYPE__QName);​
 +}
 +
 +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type) {
 +    a = soap_instring(soap,​ tag, a, type, SOAP_TYPE__QName,​ 2, 0, -1, NULL);
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type) {
 +    if (soap_out__QName(soap,​ tag ? tag : "​QName",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type) {
 +    if ((p = soap_in__QName(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a) {
 +    (void)soap;
 +    (void)a; /* appease -Wall -Werror */
 +#ifndef WITH_NOIDREF
 +    (void)soap_reference(soap,​ *a, SOAP_TYPE_string);​
 +#endif
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type) {
 +    return soap_outstring(soap,​ tag, id, a, type, SOAP_TYPE_string);​
 +}
 +
 +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type) {
 +    a = soap_instring(soap,​ tag, a, type, SOAP_TYPE_string,​ 1, 0, -1, NULL);
 +    return a;
 +}
 +
 +SOAP_FMAC3 char * * SOAP_FMAC4 soap_new_string(struct soap *soap, int n) {
 +    char * *a = static_cast<​char * *>​(soap_malloc(soap,​ (n = (n < 0 ? 1 : n)) * sizeof(char *)));
 +    for (char * *p = a; p && n--; ++p)
 +        soap_default_string(soap,​ p);
 +    return a;
 +}
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type) {
 +    if (soap_out_string(soap,​ tag ? tag : "​string",​ -2, a, type))
 +        return soap->​error;​
 +    return soap_putindependent(soap);​
 +}
 +
 +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type) {
 +    if ((p = soap_in_string(soap,​ tag, p, type)))
 +        if (soap_getindependent(soap))
 +            return NULL;
 +    return p;
 +}
 +
 +#if defined(__BORLANDC__)
 +#pragma option pop
 +#pragma option pop
 +#endif
 +
 +/* End of soapC.cpp */
 +</​code>​
 +
 +=====soapClient.cpp====
 +<code soapClient.cpp>​
 +/* soapClient.cpp
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +#if defined(__BORLANDC__)
 +#pragma option push -w-8060
 +#pragma option push -w-8004
 +#endif
 +#include "​soapH.h"​
 +
 +SOAP_SOURCE_STAMP("​@(#​) soapClient.cpp ver 2.8.78 2019-03-18 07:59:39 GMT")
 +
 +
 +SOAP_FMAC5 int SOAP_FMAC6 soap_call_h__hello(struct soap *soap, const char *soap_endpoint,​ const char *soap_action,​ char *&​_param_1) {
 +    if (soap_send_h__hello(soap,​ soap_endpoint,​ soap_action) || soap_recv_h__hello(soap,​ _param_1))
 +        return soap->​error;​
 +    return SOAP_OK;
 +}
 +
 +SOAP_FMAC5 int SOAP_FMAC6 soap_send_h__hello(struct soap *soap, const char *soap_endpoint,​ const char *soap_action) {
 +    struct h__hello soap_tmp_h__hello;​
 +    soap_begin(soap);​
 +    soap->​encodingStyle = NULL; /* use SOAP literal style */
 +    soap_serializeheader(soap);​
 +    soap_serialize_h__hello(soap,​ &​soap_tmp_h__hello);​
 +    if (soap_begin_count(soap))
 +        return soap->​error;​
 +    if ((soap->​mode & SOAP_IO_LENGTH)) {
 +        if (soap_envelope_begin_out(soap)
 +                || soap_putheader(soap)
 +                || soap_body_begin_out(soap)
 +                || soap_put_h__hello(soap,​ &​soap_tmp_h__hello,​ "​h:​hello",​ ""​)
 +                || soap_body_end_out(soap)
 +                || soap_envelope_end_out(soap))
 +            return soap->​error;​
 +    }
 +    if (soap_end_count(soap))
 +        return soap->​error;​
 +    if (soap_connect(soap,​ soap_endpoint,​ soap_action)
 +            || soap_envelope_begin_out(soap)
 +            || soap_putheader(soap)
 +            || soap_body_begin_out(soap)
 +            || soap_put_h__hello(soap,​ &​soap_tmp_h__hello,​ "​h:​hello",​ ""​)
 +            || soap_body_end_out(soap)
 +            || soap_envelope_end_out(soap)
 +            || soap_end_send(soap))
 +        return soap_closesock(soap);​
 +    return SOAP_OK;
 +}
 +
 +SOAP_FMAC5 int SOAP_FMAC6 soap_recv_h__hello(struct soap *soap, char *&​_param_1) {
 +    struct h__helloResponse *soap_tmp_h__helloResponse;​
 +    _param_1 = NULL;
 +    if (soap_begin_recv(soap)
 +            || soap_envelope_begin_in(soap)
 +            || soap_recv_header(soap)
 +            || soap_body_begin_in(soap))
 +        return soap_closesock(soap);​
 +    soap_tmp_h__helloResponse = soap_get_h__helloResponse(soap,​ NULL, "​h:​helloResponse",​ NULL);
 +    if (!soap_tmp_h__helloResponse || soap->​error)
 +        return soap_recv_fault(soap,​ 0);
 +    if (soap_body_end_in(soap)
 +            || soap_envelope_end_in(soap)
 +            || soap_end_recv(soap))
 +        return soap_closesock(soap);​
 +    _param_1 = soap_tmp_h__helloResponse->​_param_1;​
 +    return soap_closesock(soap);​
 +}
 +
 +#if defined(__BORLANDC__)
 +#pragma option pop
 +#pragma option pop
 +#endif
 +
 +/* End of soapClient.cpp */
 +</​code>​
 +
 +=====soapClientLib.cpp====
 +<code soapClientLib.cpp>​
 +/* soapClientLib.cpp
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +/** Use this file in your project build instead of the two files soapC.cpp and soapClient.cpp. This hides the serializer functions and avoids linking problems when linking multiple clients and servers. */
 +
 +#define SOAP_FMAC3 static
 +#include "​soapC.cpp"​
 +#include "​soapClient.cpp"​
 +
 +/* End of soapClientLib.cpp */
 +</​code>​
 +
 +=====soapH.h====
 +<code soapH.h>
 +/* soapH.h
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +#ifndef soapH_H
 +#define soapH_H
 +#include "​soapStub.h"​
 +#ifndef WITH_NOIDREF
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap*, const void*, int);
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap*);
 +#endif
 +
 +#ifdef __cplusplus
 +extern "​C"​ {
 +#endif
 +SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap*, const char*, int*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap*, const void*, const char*, int, int);
 +SOAP_FMAC3 void * SOAP_FMAC4 soap_dupelement(struct soap*, const void*, int);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_delelement(const void*, int);
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap*);
 +
 +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap);
 +SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap*, int, const char*, const char*, size_t*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap *soap, struct soap_clist*);​
 +SOAP_FMAC3 int SOAP_FMAC4 soap_fbase(int,​ int);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_finsert(struct soap*, int, int, void*, size_t, const void*, void**);
 +
 +#ifndef SOAP_TYPE_byte_DEFINED
 +#define SOAP_TYPE_byte_DEFINED
 +
 +inline void soap_default_byte(struct soap *soap, char *a)
 +{
 + (void)soap;​ /* appease -Wall -Werror */
 +#ifdef SOAP_DEFAULT_byte
 + *a = SOAP_DEFAULT_byte;​
 +#else
 + *a = (char)0;
 +#endif
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap*, const char*, int, const char *, const char*);
 +SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap*, const char*, char *, const char*);
 +
 +SOAP_FMAC3 char * SOAP_FMAC4 soap_new_byte(struct soap *soap, int n = -1);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap*, const char *, const char*, const char*);
 +
 +inline int soap_write_byte(struct soap *soap, char const*p)
 +{
 + soap_free_temp(soap);​
 + if (p)
 + { if (soap_begin_send(soap) || ::​soap_put_byte(soap,​ p, "​byte",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_byte(struct soap *soap, const char *URL, char const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_byte(soap,​ p, "​byte",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_byte(struct soap *soap, const char *URL, char const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_byte(soap,​ p, "​byte",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_byte(struct soap *soap, const char *URL, char const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_byte(soap,​ p, "​byte",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap*, char *, const char*, const char*);
 +
 +inline int soap_read_byte(struct soap *soap, char *p)
 +{
 + if (p)
 + { if (soap_begin_recv(soap) || ::​soap_get_byte(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_byte(struct soap *soap, const char *URL, char *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_byte(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_byte(struct soap *soap, char *p)
 +{
 + if (::​soap_read_byte(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#ifndef SOAP_TYPE_int_DEFINED
 +#define SOAP_TYPE_int_DEFINED
 +
 +inline void soap_default_int(struct soap *soap, int *a)
 +{
 + (void)soap;​ /* appease -Wall -Werror */
 +#ifdef SOAP_DEFAULT_int
 + *a = SOAP_DEFAULT_int;​
 +#else
 + *a = (int)0;
 +#endif
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap*, const char*, int, const int *, const char*);
 +SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap*, const char*, int *, const char*);
 +
 +SOAP_FMAC3 int * SOAP_FMAC4 soap_new_int(struct soap *soap, int n = -1);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap*, const int *, const char*, const char*);
 +
 +inline int soap_write_int(struct soap *soap, int const*p)
 +{
 + soap_free_temp(soap);​
 + if (p)
 + { if (soap_begin_send(soap) || ::​soap_put_int(soap,​ p, "​int",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_int(struct soap *soap, const char *URL, int const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_int(soap,​ p, "​int",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_int(struct soap *soap, const char *URL, int const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_int(soap,​ p, "​int",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_int(struct soap *soap, const char *URL, int const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_int(soap,​ p, "​int",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap*, int *, const char*, const char*);
 +
 +inline int soap_read_int(struct soap *soap, int *p)
 +{
 + if (p)
 + { if (soap_begin_recv(soap) || ::​soap_get_int(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_int(struct soap *soap, const char *URL, int *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_int(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_int(struct soap *soap, int *p)
 +{
 + if (::​soap_read_int(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_SOAP_ENV__Fault_DEFINED
 +#define SOAP_TYPE_SOAP_ENV__Fault_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap*, const char*, int, const struct SOAP_ENV__Fault *, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap*, const char*, struct SOAP_ENV__Fault *, const char*);
 +SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct SOAP_ENV__Fault * soap_new_SOAP_ENV__Fault(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_SOAP_ENV__Fault(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct SOAP_ENV__Fault * soap_new_req_SOAP_ENV__Fault(
 + struct soap *soap)
 +{
 + struct SOAP_ENV__Fault *_p = ::​soap_new_SOAP_ENV__Fault(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Fault(soap,​ _p);
 + }
 + return _p;
 +}
 +
 +inline struct SOAP_ENV__Fault * soap_new_set_SOAP_ENV__Fault(
 + struct soap *soap,
 + char *faultcode,
 + char *faultstring,​
 + char *faultactor,​
 + struct SOAP_ENV__Detail *detail,
 + struct SOAP_ENV__Code *SOAP_ENV__Code,​
 + struct SOAP_ENV__Reason *SOAP_ENV__Reason,​
 + char *SOAP_ENV__Node,​
 + char *SOAP_ENV__Role,​
 + struct SOAP_ENV__Detail *SOAP_ENV__Detail)
 +{
 + struct SOAP_ENV__Fault *_p = ::​soap_new_SOAP_ENV__Fault(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Fault(soap,​ _p);
 + _p->​faultcode = faultcode;
 + _p->​faultstring = faultstring;​
 + _p->​faultactor = faultactor;
 + _p->​detail = detail;
 + _p->​SOAP_ENV__Code = SOAP_ENV__Code;​
 + _p->​SOAP_ENV__Reason = SOAP_ENV__Reason;​
 + _p->​SOAP_ENV__Node = SOAP_ENV__Node;​
 + _p->​SOAP_ENV__Role = SOAP_ENV__Role;​
 + _p->​SOAP_ENV__Detail = SOAP_ENV__Detail;​
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *, const char*, const char*);
 +
 +inline int soap_write_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_SOAP_ENV__Fault(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Fault(soap,​ p, "​SOAP-ENV:​Fault",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Fault(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Fault(soap,​ p, "​SOAP-ENV:​Fault",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Fault(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Fault(soap,​ p, "​SOAP-ENV:​Fault",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Fault(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Fault(soap,​ p, "​SOAP-ENV:​Fault",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *, const char*, const char*);
 +
 +inline int soap_read_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
 +{
 + if (p)
 + { ::​soap_default_SOAP_ENV__Fault(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_SOAP_ENV__Fault(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_SOAP_ENV__Fault(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
 +{
 + if (::​soap_read_SOAP_ENV__Fault(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_SOAP_ENV__Reason_DEFINED
 +#define SOAP_TYPE_SOAP_ENV__Reason_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap*, const char*, int, const struct SOAP_ENV__Reason *, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason *, const char*);
 +SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct SOAP_ENV__Reason * soap_new_SOAP_ENV__Reason(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_SOAP_ENV__Reason(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct SOAP_ENV__Reason * soap_new_req_SOAP_ENV__Reason(
 + struct soap *soap)
 +{
 + struct SOAP_ENV__Reason *_p = ::​soap_new_SOAP_ENV__Reason(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Reason(soap,​ _p);
 + }
 + return _p;
 +}
 +
 +inline struct SOAP_ENV__Reason * soap_new_set_SOAP_ENV__Reason(
 + struct soap *soap,
 + char *SOAP_ENV__Text)
 +{
 + struct SOAP_ENV__Reason *_p = ::​soap_new_SOAP_ENV__Reason(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Reason(soap,​ _p);
 + _p->​SOAP_ENV__Text = SOAP_ENV__Text;​
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *, const char*, const char*);
 +
 +inline int soap_write_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_SOAP_ENV__Reason(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Reason(soap,​ p, "​SOAP-ENV:​Reason",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Reason(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Reason(soap,​ p, "​SOAP-ENV:​Reason",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Reason(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Reason(soap,​ p, "​SOAP-ENV:​Reason",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Reason(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Reason(soap,​ p, "​SOAP-ENV:​Reason",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *, const char*, const char*);
 +
 +inline int soap_read_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
 +{
 + if (p)
 + { ::​soap_default_SOAP_ENV__Reason(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_SOAP_ENV__Reason(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_SOAP_ENV__Reason(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
 +{
 + if (::​soap_read_SOAP_ENV__Reason(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_SOAP_ENV__Detail_DEFINED
 +#define SOAP_TYPE_SOAP_ENV__Detail_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap*, const char*, int, const struct SOAP_ENV__Detail *, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail *, const char*);
 +SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct SOAP_ENV__Detail * soap_new_SOAP_ENV__Detail(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_SOAP_ENV__Detail(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct SOAP_ENV__Detail * soap_new_req_SOAP_ENV__Detail(
 + struct soap *soap,
 + int __type,
 + void *fault)
 +{
 + struct SOAP_ENV__Detail *_p = ::​soap_new_SOAP_ENV__Detail(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Detail(soap,​ _p);
 + _p->​__type = __type;
 + _p->​fault = fault;
 + }
 + return _p;
 +}
 +
 +inline struct SOAP_ENV__Detail * soap_new_set_SOAP_ENV__Detail(
 + struct soap *soap,
 + char *__any,
 + int __type,
 + void *fault)
 +{
 + struct SOAP_ENV__Detail *_p = ::​soap_new_SOAP_ENV__Detail(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Detail(soap,​ _p);
 + _p->​__any = __any;
 + _p->​__type = __type;
 + _p->​fault = fault;
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *, const char*, const char*);
 +
 +inline int soap_write_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_SOAP_ENV__Detail(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Detail(soap,​ p, "​SOAP-ENV:​Detail",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Detail(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Detail(soap,​ p, "​SOAP-ENV:​Detail",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Detail(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Detail(soap,​ p, "​SOAP-ENV:​Detail",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Detail(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Detail(soap,​ p, "​SOAP-ENV:​Detail",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *, const char*, const char*);
 +
 +inline int soap_read_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
 +{
 + if (p)
 + { ::​soap_default_SOAP_ENV__Detail(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_SOAP_ENV__Detail(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_SOAP_ENV__Detail(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
 +{
 + if (::​soap_read_SOAP_ENV__Detail(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_SOAP_ENV__Code_DEFINED
 +#define SOAP_TYPE_SOAP_ENV__Code_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap*, const char*, int, const struct SOAP_ENV__Code *, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code *, const char*);
 +SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct SOAP_ENV__Code * soap_new_SOAP_ENV__Code(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_SOAP_ENV__Code(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct SOAP_ENV__Code * soap_new_req_SOAP_ENV__Code(
 + struct soap *soap)
 +{
 + struct SOAP_ENV__Code *_p = ::​soap_new_SOAP_ENV__Code(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Code(soap,​ _p);
 + }
 + return _p;
 +}
 +
 +inline struct SOAP_ENV__Code * soap_new_set_SOAP_ENV__Code(
 + struct soap *soap,
 + char *SOAP_ENV__Value,​
 + struct SOAP_ENV__Code *SOAP_ENV__Subcode)
 +{
 + struct SOAP_ENV__Code *_p = ::​soap_new_SOAP_ENV__Code(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Code(soap,​ _p);
 + _p->​SOAP_ENV__Value = SOAP_ENV__Value;​
 + _p->​SOAP_ENV__Subcode = SOAP_ENV__Subcode;​
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *, const char*, const char*);
 +
 +inline int soap_write_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_SOAP_ENV__Code(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Code(soap,​ p, "​SOAP-ENV:​Code",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Code(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Code(soap,​ p, "​SOAP-ENV:​Code",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Code(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Code(soap,​ p, "​SOAP-ENV:​Code",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Code(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Code(soap,​ p, "​SOAP-ENV:​Code",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *, const char*, const char*);
 +
 +inline int soap_read_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
 +{
 + if (p)
 + { ::​soap_default_SOAP_ENV__Code(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_SOAP_ENV__Code(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_SOAP_ENV__Code(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
 +{
 + if (::​soap_read_SOAP_ENV__Code(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_SOAP_ENV__Header_DEFINED
 +#define SOAP_TYPE_SOAP_ENV__Header_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap*, const char*, int, const struct SOAP_ENV__Header *, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap*, const char*, struct SOAP_ENV__Header *, const char*);
 +SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct SOAP_ENV__Header * soap_new_SOAP_ENV__Header(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_SOAP_ENV__Header(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct SOAP_ENV__Header * soap_new_req_SOAP_ENV__Header(
 + struct soap *soap)
 +{
 + struct SOAP_ENV__Header *_p = ::​soap_new_SOAP_ENV__Header(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Header(soap,​ _p);
 + }
 + return _p;
 +}
 +
 +inline struct SOAP_ENV__Header * soap_new_set_SOAP_ENV__Header(
 + struct soap *soap)
 +{
 + struct SOAP_ENV__Header *_p = ::​soap_new_SOAP_ENV__Header(soap);​
 + if (_p)
 + { ::​soap_default_SOAP_ENV__Header(soap,​ _p);
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *, const char*, const char*);
 +
 +inline int soap_write_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_SOAP_ENV__Header(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Header(soap,​ p, "​SOAP-ENV:​Header",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Header(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Header(soap,​ p, "​SOAP-ENV:​Header",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Header(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Header(soap,​ p, "​SOAP-ENV:​Header",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_SOAP_ENV__Header(soap,​ p), 0) || ::​soap_put_SOAP_ENV__Header(soap,​ p, "​SOAP-ENV:​Header",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *, const char*, const char*);
 +
 +inline int soap_read_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
 +{
 + if (p)
 + { ::​soap_default_SOAP_ENV__Header(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_SOAP_ENV__Header(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_SOAP_ENV__Header(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
 +{
 + if (::​soap_read_SOAP_ENV__Header(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#endif
 +
 +#ifndef SOAP_TYPE_h__hello_DEFINED
 +#define SOAP_TYPE_h__hello_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_h__hello(struct soap*, struct h__hello *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_h__hello(struct soap*, const struct h__hello *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_h__hello(struct soap*, const char*, int, const struct h__hello *, const char*);
 +SOAP_FMAC3 struct h__hello * SOAP_FMAC4 soap_in_h__hello(struct soap*, const char*, struct h__hello *, const char*);
 +SOAP_FMAC1 struct h__hello * SOAP_FMAC2 soap_instantiate_h__hello(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct h__hello * soap_new_h__hello(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_h__hello(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct h__hello * soap_new_req_h__hello(
 + struct soap *soap)
 +{
 + struct h__hello *_p = ::​soap_new_h__hello(soap);​
 + if (_p)
 + { ::​soap_default_h__hello(soap,​ _p);
 + }
 + return _p;
 +}
 +
 +inline struct h__hello * soap_new_set_h__hello(
 + struct soap *soap)
 +{
 + struct h__hello *_p = ::​soap_new_h__hello(soap);​
 + if (_p)
 + { ::​soap_default_h__hello(soap,​ _p);
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_h__hello(struct soap*, const struct h__hello *, const char*, const char*);
 +
 +inline int soap_write_h__hello(struct soap *soap, struct h__hello const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_h__hello(soap,​ p), 0) || ::​soap_put_h__hello(soap,​ p, "​h:​hello",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_h__hello(struct soap *soap, const char *URL, struct h__hello const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_h__hello(soap,​ p), 0) || ::​soap_put_h__hello(soap,​ p, "​h:​hello",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_h__hello(struct soap *soap, const char *URL, struct h__hello const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_h__hello(soap,​ p), 0) || ::​soap_put_h__hello(soap,​ p, "​h:​hello",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_h__hello(struct soap *soap, const char *URL, struct h__hello const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_h__hello(soap,​ p), 0) || ::​soap_put_h__hello(soap,​ p, "​h:​hello",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct h__hello * SOAP_FMAC4 soap_get_h__hello(struct soap*, struct h__hello *, const char*, const char*);
 +
 +inline int soap_read_h__hello(struct soap *soap, struct h__hello *p)
 +{
 + if (p)
 + { ::​soap_default_h__hello(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_h__hello(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_h__hello(struct soap *soap, const char *URL, struct h__hello *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_h__hello(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_h__hello(struct soap *soap, struct h__hello *p)
 +{
 + if (::​soap_read_h__hello(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#ifndef SOAP_TYPE_h__helloResponse_DEFINED
 +#define SOAP_TYPE_h__helloResponse_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_default_h__helloResponse(struct soap*, struct h__helloResponse *);
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_h__helloResponse(struct soap*, const struct h__helloResponse *);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_h__helloResponse(struct soap*, const char*, int, const struct h__helloResponse *, const char*);
 +SOAP_FMAC3 struct h__helloResponse * SOAP_FMAC4 soap_in_h__helloResponse(struct soap*, const char*, struct h__helloResponse *, const char*);
 +SOAP_FMAC1 struct h__helloResponse * SOAP_FMAC2 soap_instantiate_h__helloResponse(struct soap*, int, const char*, const char*, size_t*);
 +
 +inline struct h__helloResponse * soap_new_h__helloResponse(struct soap *soap, int n = -1)
 +{
 + return soap_instantiate_h__helloResponse(soap,​ n, NULL, NULL, NULL);
 +}
 +
 +inline struct h__helloResponse * soap_new_req_h__helloResponse(
 + struct soap *soap,
 + char *_param_1)
 +{
 + struct h__helloResponse *_p = ::​soap_new_h__helloResponse(soap);​
 + if (_p)
 + { ::​soap_default_h__helloResponse(soap,​ _p);
 + _p->​_param_1 = _param_1;
 + }
 + return _p;
 +}
 +
 +inline struct h__helloResponse * soap_new_set_h__helloResponse(
 + struct soap *soap,
 + char *_param_1)
 +{
 + struct h__helloResponse *_p = ::​soap_new_h__helloResponse(soap);​
 + if (_p)
 + { ::​soap_default_h__helloResponse(soap,​ _p);
 + _p->​_param_1 = _param_1;
 + }
 + return _p;
 +}
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_h__helloResponse(struct soap*, const struct h__helloResponse *, const char*, const char*);
 +
 +inline int soap_write_h__helloResponse(struct soap *soap, struct h__helloResponse const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_begin_send(soap) || (::​soap_serialize_h__helloResponse(soap,​ p), 0) || ::​soap_put_h__helloResponse(soap,​ p, "​h:​helloResponse",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_h__helloResponse(struct soap *soap, const char *URL, struct h__helloResponse const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_h__helloResponse(soap,​ p), 0) || ::​soap_put_h__helloResponse(soap,​ p, "​h:​helloResponse",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_h__helloResponse(struct soap *soap, const char *URL, struct h__helloResponse const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_h__helloResponse(soap,​ p), 0) || ::​soap_put_h__helloResponse(soap,​ p, "​h:​helloResponse",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_h__helloResponse(struct soap *soap, const char *URL, struct h__helloResponse const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || (::​soap_serialize_h__helloResponse(soap,​ p), 0) || ::​soap_put_h__helloResponse(soap,​ p, "​h:​helloResponse",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 struct h__helloResponse * SOAP_FMAC4 soap_get_h__helloResponse(struct soap*, struct h__helloResponse *, const char*, const char*);
 +
 +inline int soap_read_h__helloResponse(struct soap *soap, struct h__helloResponse *p)
 +{
 + if (p)
 + { ::​soap_default_h__helloResponse(soap,​ p);
 + if (soap_begin_recv(soap) || ::​soap_get_h__helloResponse(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_h__helloResponse(struct soap *soap, const char *URL, struct h__helloResponse *p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_h__helloResponse(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_h__helloResponse(struct soap *soap, struct h__helloResponse *p)
 +{
 + if (::​soap_read_h__helloResponse(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Reason_DEFINED
 +#define SOAP_TYPE_PointerToSOAP_ENV__Reason_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap*, const char *, int, struct SOAP_ENV__Reason *const*, const char *);
 +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason **, const char*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*, const char*, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason **, const char*, const char*);
 +#endif
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Detail_DEFINED
 +#define SOAP_TYPE_PointerToSOAP_ENV__Detail_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap*, const char *, int, struct SOAP_ENV__Detail *const*, const char *);
 +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail **, const char*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*, const char*, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail **, const char*, const char*);
 +#endif
 +
 +#endif
 +
 +#ifndef WITH_NOGLOBAL
 +
 +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Code_DEFINED
 +#define SOAP_TYPE_PointerToSOAP_ENV__Code_DEFINED
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap*, const char *, int, struct SOAP_ENV__Code *const*, const char *);
 +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code **, const char*);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*, const char*, const char*);
 +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code **, const char*, const char*);
 +#endif
 +
 +#endif
 +
 +#ifndef SOAP_TYPE__QName_DEFINED
 +#define SOAP_TYPE__QName_DEFINED
 +
 +inline void soap_default__QName(struct soap *soap, char **a)
 +{
 + (void)soap;​ /* appease -Wall -Werror */
 +#ifdef SOAP_DEFAULT__QName
 + *a = SOAP_DEFAULT__QName;​
 +#else
 + *a = (char *)0;
 +#endif
 +}
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap*, char *const*);
 +
 +#define soap__QName2s(soap,​ a) soap_QName2s(soap,​ (a))
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap*, const char*, int, char*const*,​ const char*);
 +
 +#define soap_s2_QName(soap,​ s, a) soap_s2QName((soap),​ (s), (char**)(a),​ 0, -1, NULL)
 +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap*, const char*, char **, const char*);
 +
 +#define soap_instantiate__QName soap_instantiate_string
 +
 +
 +#define soap_new__QName soap_new_string
 +
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap*, char *const*, const char*, const char*);
 +
 +inline int soap_write__QName(struct soap *soap, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (p)
 + { if (soap_begin_send(soap) || ::​soap_put__QName(soap,​ p, "​QName",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT__QName(struct soap *soap, const char *URL, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put__QName(soap,​ p, "​QName",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH__QName(struct soap *soap, const char *URL, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put__QName(soap,​ p, "​QName",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send__QName(struct soap *soap, const char *URL, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put__QName(soap,​ p, "​QName",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap*, char **, const char*, const char*);
 +
 +inline int soap_read__QName(struct soap *soap, char **p)
 +{
 + if (p)
 + { if (soap_begin_recv(soap) || ::​soap_get__QName(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET__QName(struct soap *soap, const char *URL, char **p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read__QName(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv__QName(struct soap *soap, char **p)
 +{
 + if (::​soap_read__QName(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#ifndef SOAP_TYPE__XML_DEFINED
 +#define SOAP_TYPE__XML_DEFINED
 +#endif
 +
 +#ifndef SOAP_TYPE_string_DEFINED
 +#define SOAP_TYPE_string_DEFINED
 +
 +inline void soap_default_string(struct soap *soap, char **a)
 +{
 + (void)soap;​ /* appease -Wall -Werror */
 +#ifdef SOAP_DEFAULT_string
 + *a = SOAP_DEFAULT_string;​
 +#else
 + *a = (char *)0;
 +#endif
 +}
 +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap*, char *const*);
 +
 +#define soap_string2s(soap,​ a) (a)
 +SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap*, const char*, int, char*const*,​ const char*);
 +
 +#define soap_s2string(soap,​ s, a) soap_s2char((soap),​ (s), (char**)(a),​ 1, 0, -1, NULL)
 +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap*, const char*, char **, const char*);
 +
 +SOAP_FMAC3 char * * SOAP_FMAC4 soap_new_string(struct soap *soap, int n = -1);
 +SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap*, char *const*, const char*, const char*);
 +
 +inline int soap_write_string(struct soap *soap, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (p)
 + { if (soap_begin_send(soap) || ::​soap_put_string(soap,​ p, "​string",​ ""​) || soap_end_send(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_PUT_string(struct soap *soap, const char *URL, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PUT(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_string(soap,​ p, "​string",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_PATCH_string(struct soap *soap, const char *URL, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_PATCH(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_string(soap,​ p, "​string",​ ""​) || soap_end_send(soap) || soap_recv_empty_response(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +
 +inline int soap_POST_send_string(struct soap *soap, const char *URL, char *const*p)
 +{
 + soap_free_temp(soap);​
 + if (soap_POST(soap,​ URL, NULL, "​text/​xml;​ charset=utf-8"​) || ::​soap_put_string(soap,​ p, "​string",​ ""​) || soap_end_send(soap))
 + return soap_closesock(soap);​
 + return SOAP_OK;
 +}
 +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap*, char **, const char*, const char*);
 +
 +inline int soap_read_string(struct soap *soap, char **p)
 +{
 + if (p)
 + { if (soap_begin_recv(soap) || ::​soap_get_string(soap,​ p, NULL, NULL) == NULL || soap_end_recv(soap))
 + return soap->​error;​
 + }
 + return SOAP_OK;
 +}
 +
 +inline int soap_GET_string(struct soap *soap, const char *URL, char **p)
 +{
 + if (soap_GET(soap,​ URL, NULL) || ::​soap_read_string(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +
 +inline int soap_POST_recv_string(struct soap *soap, char **p)
 +{
 + if (::​soap_read_string(soap,​ p))
 + return soap_closesock(soap);​
 + return soap_closesock(soap);​
 +}
 +#endif
 +
 +#endif
 +
 +/* End of soapH.h */
 +</​code>​
 +
 +=====soapServer.cpp====
 +<code soapServer.cpp>​
 +/* soapServer.cpp
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +#if defined(__BORLANDC__)
 +#pragma option push -w-8060
 +#pragma option push -w-8004
 +#endif
 +#include "​soapH.h"​
 +
 +SOAP_SOURCE_STAMP("​@(#​) soapServer.cpp ver 2.8.78 2019-03-18 07:59:39 GMT")
 +extern "​C"​ SOAP_FMAC5 int SOAP_FMAC6 soap_serve(struct soap *soap) {
 +#ifndef WITH_FASTCGI
 +    soap->​keep_alive = soap->​max_keep_alive + 1;
 +#endif
 +    do {
 +#ifndef WITH_FASTCGI
 +        if (soap->​keep_alive > 0 && soap->​max_keep_alive > 0)
 +            soap->​keep_alive--;​
 +#endif
 +        if (soap_begin_serve(soap)) {
 +            if (soap->​error >= SOAP_STOP)
 +                continue;
 +            return soap->​error;​
 +        }
 +        if ((soap_serve_request(soap) || (soap->​fserveloop && soap->​fserveloop(soap))) && soap->​error && soap->​error < SOAP_STOP) {
 +#ifdef WITH_FASTCGI
 +            soap_send_fault(soap);​
 +#else
 +            return soap_send_fault(soap);​
 +#endif
 +        }
 +#ifdef WITH_FASTCGI
 +        soap_destroy(soap);​
 +        soap_end(soap);​
 +    } while (1);
 +#else
 +    }
 +    while (soap->​keep_alive);​
 +#endif
 +    return SOAP_OK;
 +}
 +
 +#ifndef WITH_NOSERVEREQUEST
 +extern "​C"​ SOAP_FMAC5 int SOAP_FMAC6 soap_serve_request(struct soap *soap) {
 +    soap_peek_element(soap);​
 +    if (!soap_match_tag(soap,​ soap->​tag,​ "​h:​hello"​))
 +        return soap_serve_h__hello(soap);​
 +    return soap->​error = SOAP_NO_METHOD;​
 +}
 +#endif
 +
 +SOAP_FMAC5 int SOAP_FMAC6 soap_serve_h__hello(struct soap *soap) {
 +    struct h__hello soap_tmp_h__hello;​
 +    struct h__helloResponse soap_tmp_h__helloResponse;​
 +    soap_default_h__helloResponse(soap,​ &​soap_tmp_h__helloResponse);​
 +    soap_default_h__hello(soap,​ &​soap_tmp_h__hello);​
 +    if (!soap_get_h__hello(soap,​ &​soap_tmp_h__hello,​ "​h:​hello",​ NULL))
 +        return soap->​error;​
 +    if (soap_body_end_in(soap)
 +            || soap_envelope_end_in(soap)
 +            || soap_end_recv(soap))
 +        return soap->​error;​
 +    soap->​error = h__hello(soap,​ soap_tmp_h__helloResponse._param_1);​
 +    if (soap->​error)
 +        return soap->​error;​
 +    soap->​encodingStyle = NULL; /* use SOAP literal style */
 +    soap_serializeheader(soap);​
 +    soap_serialize_h__helloResponse(soap,​ &​soap_tmp_h__helloResponse);​
 +    if (soap_begin_count(soap))
 +        return soap->​error;​
 +    if ((soap->​mode & SOAP_IO_LENGTH)) {
 +        if (soap_envelope_begin_out(soap)
 +                || soap_putheader(soap)
 +                || soap_body_begin_out(soap)
 +                || soap_put_h__helloResponse(soap,​ &​soap_tmp_h__helloResponse,​ "​h:​helloResponse",​ ""​)
 +                || soap_body_end_out(soap)
 +                || soap_envelope_end_out(soap))
 +            return soap->​error;​
 +    };
 +    if (soap_end_count(soap)
 +            || soap_response(soap,​ SOAP_OK)
 +            || soap_envelope_begin_out(soap)
 +            || soap_putheader(soap)
 +            || soap_body_begin_out(soap)
 +            || soap_put_h__helloResponse(soap,​ &​soap_tmp_h__helloResponse,​ "​h:​helloResponse",​ ""​)
 +            || soap_body_end_out(soap)
 +            || soap_envelope_end_out(soap)
 +            || soap_end_send(soap))
 +        return soap->​error;​
 +    return soap_closesock(soap);​
 +}
 +
 +#if defined(__BORLANDC__)
 +#pragma option pop
 +#pragma option pop
 +#endif
 +
 +/* End of soapServer.cpp */
 +</​code>​
 +
 +=====soapServerLib.cpp====
 +<code soapServerLib.cpp>​
 +/* soapServerLib.cpp
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +/** Use this file in your project build instead of the two files soapC.cpp and soapServer.cpp. This hides the serializer functions and avoids linking problems when linking multiple clients and servers. */
 +
 +#define SOAP_FMAC3 static
 +#include "​soapC.cpp"​
 +#include "​soapServer.cpp"​
 +
 +/* End of soapServerLib.cpp */
 +</​code>​
 +
 +=====soapStub.h====
 +<code soapStub.h>​
 +/* soapStub.h
 +   ​Generated by gSOAP 2.8.78 for hello.h
 +
 +gSOAP XML Web services tools
 +Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
 +The soapcpp2 tool and its generated software are released under the GPL.
 +This program is released under the GPL with the additional exemption that
 +compiling, linking, and/or using OpenSSL is allowed.
 +--------------------------------------------------------------------------------
 +A commercial use license is available from Genivia Inc., contact@genivia.com
 +--------------------------------------------------------------------------------
 +*/
 +
 +
 +#ifndef soapStub_H
 +#define soapStub_H
 +#include "​stdsoap2.h"​
 +#if GSOAP_VERSION != 20878
 +# error "GSOAP VERSION 20878 MISMATCH IN GENERATED CODE VERSUS LIBRARY CODE: PLEASE REINSTALL PACKAGE"​
 +#endif
 +
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Types with Custom Serializers ​                                             *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Classes, Structs and Unions ​                                               *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +struct h__helloResponse;​ /​* hello.h:1 */
 +struct h__hello;​ /​* hello.h:1 */
 +
 +/* hello.h:1 */
 +#ifndef SOAP_TYPE_h__helloResponse
 +#define SOAP_TYPE_h__helloResponse (11)
 +/* complex XML schema type '​h:​helloResponse':​ */
 +struct SOAP_CMAC h__helloResponse {
 +      public:
 +        /** Required element '​param-1'​ of XML schema type '​xsd:​string'​ */
 +        char *_param_1;
 +      public:
 +        /** Return unique type id SOAP_TYPE_h__helloResponse */
 +        long soap_type() const { return SOAP_TYPE_h__helloResponse;​ }
 +        /** Constructor with member initializations */
 +        h__helloResponse() : _param_1() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 h__helloResponse * SOAP_FMAC2 soap_instantiate_h__helloResponse(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +
 +/* hello.h:1 */
 +#ifndef SOAP_TYPE_h__hello
 +#define SOAP_TYPE_h__hello (12)
 +/* complex XML schema type '​h:​hello':​ */
 +struct SOAP_CMAC h__hello {
 +      public:
 +        /** Return unique type id SOAP_TYPE_h__hello */
 +        long soap_type() const { return SOAP_TYPE_h__hello;​ }
 +        /** Constructor with member initializations */
 +        h__hello() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 h__hello * SOAP_FMAC2 soap_instantiate_h__hello(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +
 +/* hello.h:2 */
 +#ifndef WITH_NOGLOBAL
 +#ifndef SOAP_TYPE_SOAP_ENV__Header
 +#define SOAP_TYPE_SOAP_ENV__Header (13)
 +/* SOAP_ENV__Header:​ */
 +struct SOAP_CMAC SOAP_ENV__Header {
 +      public:
 +        /** Return unique type id SOAP_TYPE_SOAP_ENV__Header */
 +        long soap_type() const { return SOAP_TYPE_SOAP_ENV__Header;​ }
 +        /** Constructor with member initializations */
 +        SOAP_ENV__Header() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +#endif
 +
 +/* hello.h:2 */
 +#ifndef WITH_NOGLOBAL
 +#ifndef SOAP_TYPE_SOAP_ENV__Code
 +#define SOAP_TYPE_SOAP_ENV__Code (14)
 +/* Type SOAP_ENV__Code is a recursive data type, (in)directly referencing itself through its (base or derived class) members */
 +/* SOAP_ENV__Code:​ */
 +struct SOAP_CMAC SOAP_ENV__Code {
 +      public:
 +        /** Optional element '​SOAP-ENV:​Value'​ of XML schema type '​xsd:​QName'​ */
 +        char *SOAP_ENV__Value;​
 +        /** Optional element '​SOAP-ENV:​Subcode'​ of XML schema type '​SOAP-ENV:​Code'​ */
 +        struct SOAP_ENV__Code *SOAP_ENV__Subcode;​
 +      public:
 +        /** Return unique type id SOAP_TYPE_SOAP_ENV__Code */
 +        long soap_type() const { return SOAP_TYPE_SOAP_ENV__Code;​ }
 +        /** Constructor with member initializations */
 +        SOAP_ENV__Code() : SOAP_ENV__Value(),​ SOAP_ENV__Subcode() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +#endif
 +
 +/* hello.h:2 */
 +#ifndef WITH_NOGLOBAL
 +#ifndef SOAP_TYPE_SOAP_ENV__Detail
 +#define SOAP_TYPE_SOAP_ENV__Detail (16)
 +/* SOAP_ENV__Detail:​ */
 +struct SOAP_CMAC SOAP_ENV__Detail {
 +      public:
 +        char *__any;
 +        /** Any type of element '​fault'​ assigned to fault with its SOAP_TYPE_<​typename>​ assigned to __type */
 +        /** Do not create a cyclic data structure throught this member unless SOAP encoding or SOAP_XML_GRAPH are used for id-ref serialization */
 +        int __type;
 +        void *fault;
 +      public:
 +        /** Return unique type id SOAP_TYPE_SOAP_ENV__Detail */
 +        long soap_type() const { return SOAP_TYPE_SOAP_ENV__Detail;​ }
 +        /** Constructor with member initializations */
 +        SOAP_ENV__Detail() : __any(), __type(), fault() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +#endif
 +
 +/* hello.h:2 */
 +#ifndef WITH_NOGLOBAL
 +#ifndef SOAP_TYPE_SOAP_ENV__Reason
 +#define SOAP_TYPE_SOAP_ENV__Reason (18)
 +/* SOAP_ENV__Reason:​ */
 +struct SOAP_CMAC SOAP_ENV__Reason {
 +      public:
 +        /** Optional element '​SOAP-ENV:​Text'​ of XML schema type '​xsd:​string'​ */
 +        char *SOAP_ENV__Text;​
 +      public:
 +        /** Return unique type id SOAP_TYPE_SOAP_ENV__Reason */
 +        long soap_type() const { return SOAP_TYPE_SOAP_ENV__Reason;​ }
 +        /** Constructor with member initializations */
 +        SOAP_ENV__Reason() : SOAP_ENV__Text() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +#endif
 +
 +/* hello.h:2 */
 +#ifndef WITH_NOGLOBAL
 +#ifndef SOAP_TYPE_SOAP_ENV__Fault
 +#define SOAP_TYPE_SOAP_ENV__Fault (19)
 +/* SOAP_ENV__Fault:​ */
 +struct SOAP_CMAC SOAP_ENV__Fault {
 +      public:
 +        /** Optional element '​faultcode'​ of XML schema type '​xsd:​QName'​ */
 +        char *faultcode;
 +        /** Optional element '​faultstring'​ of XML schema type '​xsd:​string'​ */
 +        char *faultstring;​
 +        /** Optional element '​faultactor'​ of XML schema type '​xsd:​string'​ */
 +        char *faultactor;​
 +        /** Optional element '​detail'​ of XML schema type '​SOAP-ENV:​Detail'​ */
 +        struct SOAP_ENV__Detail *detail;
 +        /** Optional element '​SOAP-ENV:​Code'​ of XML schema type '​SOAP-ENV:​Code'​ */
 +        struct SOAP_ENV__Code *SOAP_ENV__Code;​
 +        /** Optional element '​SOAP-ENV:​Reason'​ of XML schema type '​SOAP-ENV:​Reason'​ */
 +        struct SOAP_ENV__Reason *SOAP_ENV__Reason;​
 +        /** Optional element '​SOAP-ENV:​Node'​ of XML schema type '​xsd:​string'​ */
 +        char *SOAP_ENV__Node;​
 +        /** Optional element '​SOAP-ENV:​Role'​ of XML schema type '​xsd:​string'​ */
 +        char *SOAP_ENV__Role;​
 +        /** Optional element '​SOAP-ENV:​Detail'​ of XML schema type '​SOAP-ENV:​Detail'​ */
 +        struct SOAP_ENV__Detail *SOAP_ENV__Detail;​
 +      public:
 +        /** Return unique type id SOAP_TYPE_SOAP_ENV__Fault */
 +        long soap_type() const { return SOAP_TYPE_SOAP_ENV__Fault;​ }
 +        /** Constructor with member initializations */
 +        SOAP_ENV__Fault() : faultcode(),​ faultstring(),​ faultactor(),​ detail(), SOAP_ENV__Code(),​ SOAP_ENV__Reason(),​ SOAP_ENV__Node(),​ SOAP_ENV__Role(),​ SOAP_ENV__Detail() { }
 +        /** Friend allocator */
 +        friend SOAP_FMAC1 SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap*, int, const char*, const char*, size_t*);
 +};
 +#endif
 +#endif
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Typedefs ​                                                                  *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +
 +/* (built-in):​0 */
 +#ifndef SOAP_TYPE__XML
 +#define SOAP_TYPE__XML (5)
 +typedef char *_XML;
 +#endif
 +
 +/* (built-in):​0 */
 +#ifndef SOAP_TYPE__QName
 +#define SOAP_TYPE__QName (6)
 +typedef char *_QName;
 +#endif
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Serializable Types                                                         *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +
 +/* char has binding name '​byte'​ for type '​xsd:​byte'​ */
 +#ifndef SOAP_TYPE_byte
 +#define SOAP_TYPE_byte (3)
 +#endif
 +
 +/* int has binding name '​int'​ for type '​xsd:​int'​ */
 +#ifndef SOAP_TYPE_int
 +#define SOAP_TYPE_int (1)
 +#endif
 +
 +/* struct SOAP_ENV__Fault has binding name '​SOAP_ENV__Fault'​ for type ''​ */
 +#ifndef SOAP_TYPE_SOAP_ENV__Fault
 +#define SOAP_TYPE_SOAP_ENV__Fault (19)
 +#endif
 +
 +/* struct SOAP_ENV__Reason has binding name '​SOAP_ENV__Reason'​ for type ''​ */
 +#ifndef SOAP_TYPE_SOAP_ENV__Reason
 +#define SOAP_TYPE_SOAP_ENV__Reason (18)
 +#endif
 +
 +/* struct SOAP_ENV__Detail has binding name '​SOAP_ENV__Detail'​ for type ''​ */
 +#ifndef SOAP_TYPE_SOAP_ENV__Detail
 +#define SOAP_TYPE_SOAP_ENV__Detail (16)
 +#endif
 +
 +/* struct SOAP_ENV__Code has binding name '​SOAP_ENV__Code'​ for type ''​ */
 +#ifndef SOAP_TYPE_SOAP_ENV__Code
 +#define SOAP_TYPE_SOAP_ENV__Code (14)
 +#endif
 +
 +/* struct SOAP_ENV__Header has binding name '​SOAP_ENV__Header'​ for type ''​ */
 +#ifndef SOAP_TYPE_SOAP_ENV__Header
 +#define SOAP_TYPE_SOAP_ENV__Header (13)
 +#endif
 +
 +/* struct h__hello has binding name '​h__hello'​ for type '​h:​hello'​ */
 +#ifndef SOAP_TYPE_h__hello
 +#define SOAP_TYPE_h__hello (12)
 +#endif
 +
 +/* struct h__helloResponse has binding name '​h__helloResponse'​ for type '​h:​helloResponse'​ */
 +#ifndef SOAP_TYPE_h__helloResponse
 +#define SOAP_TYPE_h__helloResponse (11)
 +#endif
 +
 +/* struct SOAP_ENV__Reason * has binding name '​PointerToSOAP_ENV__Reason'​ for type ''​ */
 +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Reason
 +#define SOAP_TYPE_PointerToSOAP_ENV__Reason (21)
 +#endif
 +
 +/* struct SOAP_ENV__Detail * has binding name '​PointerToSOAP_ENV__Detail'​ for type ''​ */
 +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Detail
 +#define SOAP_TYPE_PointerToSOAP_ENV__Detail (20)
 +#endif
 +
 +/* struct SOAP_ENV__Code * has binding name '​PointerToSOAP_ENV__Code'​ for type ''​ */
 +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Code
 +#define SOAP_TYPE_PointerToSOAP_ENV__Code (15)
 +#endif
 +
 +/* _QName has binding name '​_QName'​ for type '​xsd:​QName'​ */
 +#ifndef SOAP_TYPE__QName
 +#define SOAP_TYPE__QName (6)
 +#endif
 +
 +/* _XML has binding name '​_XML'​ for type ''​ */
 +#ifndef SOAP_TYPE__XML
 +#define SOAP_TYPE__XML (5)
 +#endif
 +
 +/* char * has binding name '​string'​ for type '​xsd:​string'​ */
 +#ifndef SOAP_TYPE_string
 +#define SOAP_TYPE_string (4)
 +#endif
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Externals ​                                                                 *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Client-Side Call Stub Functions ​                                           *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +    ​
 +    /** Web service synchronous operation '​soap_call_h__hello'​ to the specified endpoint and SOAP Action header, returns SOAP_OK or error code */
 +    SOAP_FMAC5 int SOAP_FMAC6 soap_call_h__hello(struct soap *soap, const char *soap_endpoint,​ const char *soap_action,​ char *&​_param_1);​
 +    /** Web service asynchronous operation '​soap_send_h__hello'​ to send a request message to the specified endpoint and SOAP Action header, returns SOAP_OK or error code */
 +    SOAP_FMAC5 int SOAP_FMAC6 soap_send_h__hello(struct soap *soap, const char *soap_endpoint,​ const char *soap_action);​
 +    /** Web service asynchronous operation '​soap_recv_h__hello'​ to receive a response message from the connected endpoint, returns SOAP_OK or error code */
 +    SOAP_FMAC5 int SOAP_FMAC6 soap_recv_h__hello(struct soap *soap, char *&​_param_1);​
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Server-Side Operations ​                                                    *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +    /** Web service operation '​h__hello'​ implementation,​ should return SOAP_OK or error code */
 +    SOAP_FMAC5 int SOAP_FMAC6 h__hello(struct soap*, char *&​_param_1);​
 +
 +/​******************************************************************************\
 + ​* ​                                                                           *
 + * Server-Side Skeletons to Invoke Service Operations ​                        *
 + ​* ​                                                                           *
 +\******************************************************************************/​
 +
 +extern "​C"​ SOAP_FMAC5 int SOAP_FMAC6 soap_serve(struct soap*);
 +
 +extern "​C"​ SOAP_FMAC5 int SOAP_FMAC6 soap_serve_request(struct soap*);
 +
 +SOAP_FMAC5 int SOAP_FMAC6 soap_serve_h__hello(struct soap*);
 +
 +#endif
 +
 +/* End of soapStub.h */
 +</​code>​
 +