wi12.unix7.org

User Tools

Site Tools

Trace: • w

Table of Contents

SOAP C++

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>

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>

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}
    };

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>

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>

hello.h

h__hello(char*&);

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;
}

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;
}

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 */

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 */

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 */

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 */

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 */

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 */

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 */

Page Tools