00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #if defined(__BORLANDC__)
00012 #pragma option push -w-8060
00013 #pragma option push -w-8004
00014 #endif
00015
00016 #include "stockQuoteH.h"
00017
00018 #ifdef __cplusplus
00019 extern "C" {
00020 #endif
00021
00022 SOAP_SOURCE_STAMP("@(#) stockQuoteC.c ver 2.8.3 2011-08-08 19:56:59 GMT")
00023
00024
00025 #ifndef WITH_NOGLOBAL
00026
00027 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
00028 {
00029 if (soap->header)
00030 soap_serialize_SOAP_ENV__Header(soap, soap->header);
00031 }
00032
00033 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
00034 {
00035 if (soap->header)
00036 { soap->part = SOAP_IN_HEADER;
00037 if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
00038 return soap->error;
00039 soap->part = SOAP_END_HEADER;
00040 }
00041 return SOAP_OK;
00042 }
00043
00044 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
00045 {
00046 soap->part = SOAP_IN_HEADER;
00047 soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
00048 soap->part = SOAP_END_HEADER;
00049 return soap->header == NULL;
00050 }
00051
00052 SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
00053 {
00054 if (!soap->header)
00055 { if ((soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header))))
00056 soap_default_SOAP_ENV__Header(soap, soap->header);
00057 }
00058 }
00059
00060 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
00061 {
00062 if (!soap->fault)
00063 { soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault));
00064 if (!soap->fault)
00065 return;
00066 soap_default_SOAP_ENV__Fault(soap, soap->fault);
00067 }
00068 if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
00069 { soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00070 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
00071 }
00072 if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
00073 { soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason));
00074 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
00075 }
00076 }
00077
00078 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
00079 {
00080 if (soap->fault)
00081 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
00082 }
00083
00084 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
00085 {
00086 if (soap->fault)
00087 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
00088 return SOAP_OK;
00089 }
00090
00091 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
00092 {
00093 return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
00094 }
00095
00096 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
00097 {
00098 soap_fault(soap);
00099 if (soap->version == 2)
00100 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
00101 return (const char**)&soap->fault->faultcode;
00102 }
00103
00104 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
00105 {
00106 soap_fault(soap);
00107 if (soap->version == 2)
00108 { if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
00109 { soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00110 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
00111 }
00112 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
00113 }
00114 return (const char**)&soap->fault->faultcode;
00115 }
00116
00117 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
00118 {
00119 soap_fault(soap);
00120 if (soap->version == 2)
00121 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
00122 return (const char**)&soap->fault->faultstring;
00123 }
00124
00125 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
00126 {
00127 soap_fault(soap);
00128 if (soap->version == 1)
00129 { if (!soap->fault->detail)
00130 { soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00131 soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
00132 }
00133 return (const char**)&soap->fault->detail->__any;
00134 }
00135 if (!soap->fault->SOAP_ENV__Detail)
00136 { soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00137 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
00138 }
00139 return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
00140 }
00141
00142 #endif
00143
00144 #ifndef WITH_NOIDREF
00145 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
00146 {
00147 int t;
00148 if (soap->version == 1)
00149 { for (;;)
00150 { if (!soap_getelement(soap, &t))
00151 if (soap->error || soap_ignore_element(soap))
00152 break;
00153 }
00154 }
00155 if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
00156 soap->error = SOAP_OK;
00157 return soap->error;
00158 }
00159 #endif
00160
00161 #ifndef WITH_NOIDREF
00162 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
00163 {
00164 if (soap_peek_element(soap))
00165 return NULL;
00166 if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
00167 *type = soap_lookup_type(soap, soap->href);
00168 switch (*type)
00169 {
00170 case SOAP_TYPE_byte:
00171 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
00172 case SOAP_TYPE_int:
00173 return soap_in_int(soap, NULL, NULL, "xsd:int");
00174 case SOAP_TYPE_PointerTo_ns1__GetQuoteResponse:
00175 return soap_in_PointerTo_ns1__GetQuoteResponse(soap, NULL, NULL, "ns1:GetQuoteResponse");
00176 case SOAP_TYPE_PointerTo_ns1__GetQuote:
00177 return soap_in_PointerTo_ns1__GetQuote(soap, NULL, NULL, "ns1:GetQuote");
00178 case SOAP_TYPE__QName:
00179 { char **s;
00180 s = soap_in__QName(soap, NULL, NULL, "xsd:QName");
00181 return s ? *s : NULL;
00182 }
00183 case SOAP_TYPE_string:
00184 { char **s;
00185 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00186 return s ? *s : NULL;
00187 }
00188 default:
00189 { const char *t = soap->type;
00190 if (!*t)
00191 t = soap->tag;
00192 if (!soap_match_tag(soap, t, "xsd:byte"))
00193 { *type = SOAP_TYPE_byte;
00194 return soap_in_byte(soap, NULL, NULL, NULL);
00195 }
00196 if (!soap_match_tag(soap, t, "xsd:int"))
00197 { *type = SOAP_TYPE_int;
00198 return soap_in_int(soap, NULL, NULL, NULL);
00199 }
00200 if (!soap_match_tag(soap, t, "xsd:QName"))
00201 { char **s;
00202 *type = SOAP_TYPE__QName;
00203 s = soap_in__QName(soap, NULL, NULL, NULL);
00204 return s ? *s : NULL;
00205 }
00206 if (!soap_match_tag(soap, t, "xsd:string"))
00207 { char **s;
00208 *type = SOAP_TYPE_string;
00209 s = soap_in_string(soap, NULL, NULL, NULL);
00210 return s ? *s : NULL;
00211 }
00212 t = soap->tag;
00213 if (!soap_match_tag(soap, t, "ns1:GetQuoteResponse"))
00214 { *type = SOAP_TYPE__ns1__GetQuoteResponse;
00215 return soap_in__ns1__GetQuoteResponse(soap, NULL, NULL, NULL);
00216 }
00217 if (!soap_match_tag(soap, t, "ns1:GetQuote"))
00218 { *type = SOAP_TYPE__ns1__GetQuote;
00219 return soap_in__ns1__GetQuote(soap, NULL, NULL, NULL);
00220 }
00221 }
00222 }
00223 soap->error = SOAP_TAG_MISMATCH;
00224 return NULL;
00225 }
00226 #endif
00227
00228 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00229 {
00230 if (!soap_peek_element(soap))
00231 { int t;
00232 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unexpected element '%s' in input (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00233 if (soap->mustUnderstand && !soap->other)
00234 return soap->error = SOAP_MUSTUNDERSTAND;
00235 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00236 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00237 return soap->error = SOAP_TAG_MISMATCH;
00238 }
00239 if (!*soap->id || !soap_getelement(soap, &t))
00240 { soap->peeked = 0;
00241 if (soap->fignore)
00242 soap->error = soap->fignore(soap, soap->tag);
00243 else
00244 soap->error = SOAP_OK;
00245 DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00246 if (!soap->error && soap->body)
00247 { soap->level++;
00248 while (!soap_ignore_element(soap))
00249 ;
00250 if (soap->error == SOAP_NO_TAG)
00251 soap->error = soap_element_end_in(soap, NULL);
00252 }
00253 }
00254 }
00255 return soap->error;
00256 }
00257
00258 #ifndef WITH_NOIDREF
00259 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00260 {
00261 int i;
00262 struct soap_plist *pp;
00263 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00264 for (i = 0; i < SOAP_PTRHASH; i++)
00265 for (pp = soap->pht[i]; pp; pp = pp->next)
00266 if (pp->mark1 == 2 || pp->mark2 == 2)
00267 if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00268 return soap->error;
00269 return SOAP_OK;
00270 }
00271 #endif
00272
00273 #ifndef WITH_NOIDREF
00274 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00275 {
00276 switch (type)
00277 {
00278 case SOAP_TYPE_byte:
00279 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00280 case SOAP_TYPE_int:
00281 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00282 case SOAP_TYPE__ns1__GetQuoteResponse:
00283 return soap_out__ns1__GetQuoteResponse(soap, "ns1:GetQuoteResponse", id, (const struct _ns1__GetQuoteResponse *)ptr, NULL);
00284 case SOAP_TYPE__ns1__GetQuote:
00285 return soap_out__ns1__GetQuote(soap, "ns1:GetQuote", id, (const struct _ns1__GetQuote *)ptr, NULL);
00286 case SOAP_TYPE_PointerTo_ns1__GetQuoteResponse:
00287 return soap_out_PointerTo_ns1__GetQuoteResponse(soap, tag, id, (struct _ns1__GetQuoteResponse *const*)ptr, "ns1:GetQuoteResponse");
00288 case SOAP_TYPE_PointerTo_ns1__GetQuote:
00289 return soap_out_PointerTo_ns1__GetQuote(soap, tag, id, (struct _ns1__GetQuote *const*)ptr, "ns1:GetQuote");
00290 case SOAP_TYPE__QName:
00291 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:QName");
00292 case SOAP_TYPE_string:
00293 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
00294 }
00295 return SOAP_OK;
00296 }
00297 #endif
00298
00299 #ifndef WITH_NOIDREF
00300 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00301 {
00302 (void)soap; (void)ptr; (void)type;
00303 switch (type)
00304 {
00305 case SOAP_TYPE___ns3__GetQuote:
00306 soap_serialize___ns3__GetQuote(soap, (const struct __ns3__GetQuote *)ptr);
00307 break;
00308 case SOAP_TYPE___ns2__GetQuote:
00309 soap_serialize___ns2__GetQuote(soap, (const struct __ns2__GetQuote *)ptr);
00310 break;
00311 case SOAP_TYPE__ns1__GetQuoteResponse:
00312 soap_serialize__ns1__GetQuoteResponse(soap, (const struct _ns1__GetQuoteResponse *)ptr);
00313 break;
00314 case SOAP_TYPE__ns1__GetQuote:
00315 soap_serialize__ns1__GetQuote(soap, (const struct _ns1__GetQuote *)ptr);
00316 break;
00317 case SOAP_TYPE_PointerTo_ns1__GetQuoteResponse:
00318 soap_serialize_PointerTo_ns1__GetQuoteResponse(soap, (struct _ns1__GetQuoteResponse *const*)ptr);
00319 break;
00320 case SOAP_TYPE_PointerTo_ns1__GetQuote:
00321 soap_serialize_PointerTo_ns1__GetQuote(soap, (struct _ns1__GetQuote *const*)ptr);
00322 break;
00323 case SOAP_TYPE__QName:
00324 soap_serialize_string(soap, (char*const*)&ptr);
00325 break;
00326 case SOAP_TYPE_string:
00327 soap_serialize_string(soap, (char*const*)&ptr);
00328 break;
00329 }
00330 }
00331 #endif
00332
00333 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00334 {
00335 (void)soap;
00336 #ifdef SOAP_DEFAULT_byte
00337 *a = SOAP_DEFAULT_byte;
00338 #else
00339 *a = (char)0;
00340 #endif
00341 }
00342
00343 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00344 {
00345 return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00346 }
00347
00348 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00349 { char *p;
00350 p = soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00351 return p;
00352 }
00353
00354 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00355 {
00356 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00357 if (soap_out_byte(soap, tag?tag:"byte", id, a, type))
00358 return soap->error;
00359 return soap_putindependent(soap);
00360 }
00361
00362 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00363 {
00364 if ((p = soap_in_byte(soap, tag, p, type)))
00365 if (soap_getindependent(soap))
00366 return NULL;
00367 return p;
00368 }
00369
00370 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00371 {
00372 (void)soap;
00373 #ifdef SOAP_DEFAULT_int
00374 *a = SOAP_DEFAULT_int;
00375 #else
00376 *a = (int)0;
00377 #endif
00378 }
00379
00380 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
00381 {
00382 return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
00383 }
00384
00385 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00386 { int *p;
00387 p = soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00388 return p;
00389 }
00390
00391 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00392 {
00393 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00394 if (soap_out_int(soap, tag?tag:"int", id, a, type))
00395 return soap->error;
00396 return soap_putindependent(soap);
00397 }
00398
00399 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00400 {
00401 if ((p = soap_in_int(soap, tag, p, type)))
00402 if (soap_getindependent(soap))
00403 return NULL;
00404 return p;
00405 }
00406
00407 #ifndef WITH_NOGLOBAL
00408
00409 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
00410 {
00411 (void)soap; (void)a;
00412 soap_default__QName(soap, &a->faultcode);
00413 soap_default_string(soap, &a->faultstring);
00414 soap_default_string(soap, &a->faultactor);
00415 a->detail = NULL;
00416 a->SOAP_ENV__Code = NULL;
00417 a->SOAP_ENV__Reason = NULL;
00418 soap_default_string(soap, &a->SOAP_ENV__Node);
00419 soap_default_string(soap, &a->SOAP_ENV__Role);
00420 a->SOAP_ENV__Detail = NULL;
00421 }
00422
00423 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
00424 {
00425 (void)soap; (void)a;
00426 soap_serialize__QName(soap, &a->faultcode);
00427 soap_serialize_string(soap, &a->faultstring);
00428 soap_serialize_string(soap, &a->faultactor);
00429 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
00430 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
00431 soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
00432 soap_serialize_string(soap, &a->SOAP_ENV__Node);
00433 soap_serialize_string(soap, &a->SOAP_ENV__Role);
00434 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
00435 }
00436
00437 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)
00438 {
00439 const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
00440 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
00441 return soap->error;
00442 if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
00443 return soap->error;
00444 if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
00445 return soap->error;
00446 if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
00447 return soap->error;
00448 if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
00449 return soap->error;
00450 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
00451 return soap->error;
00452 if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
00453 return soap->error;
00454 if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
00455 return soap->error;
00456 if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
00457 return soap->error;
00458 if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
00459 return soap->error;
00460 return soap_element_end_out(soap, tag);
00461 }
00462
00463 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)
00464 {
00465 size_t soap_flag_faultcode = 1;
00466 size_t soap_flag_faultstring = 1;
00467 size_t soap_flag_faultactor = 1;
00468 size_t soap_flag_detail = 1;
00469 size_t soap_flag_SOAP_ENV__Code = 1;
00470 size_t soap_flag_SOAP_ENV__Reason = 1;
00471 size_t soap_flag_SOAP_ENV__Node = 1;
00472 size_t soap_flag_SOAP_ENV__Role = 1;
00473 size_t soap_flag_SOAP_ENV__Detail = 1;
00474 if (soap_element_begin_in(soap, tag, 0, type))
00475 return NULL;
00476 a = (struct SOAP_ENV__Fault *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0, NULL, NULL, NULL);
00477 if (!a)
00478 return NULL;
00479 soap_default_SOAP_ENV__Fault(soap, a);
00480 if (soap->body && !*soap->href)
00481 {
00482 for (;;)
00483 { soap->error = SOAP_TAG_MISMATCH;
00484 if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00485 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
00486 { soap_flag_faultcode--;
00487 continue;
00488 }
00489 if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00490 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
00491 { soap_flag_faultstring--;
00492 continue;
00493 }
00494 if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00495 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
00496 { soap_flag_faultactor--;
00497 continue;
00498 }
00499 if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
00500 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
00501 { soap_flag_detail--;
00502 continue;
00503 }
00504 if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
00505 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
00506 { soap_flag_SOAP_ENV__Code--;
00507 continue;
00508 }
00509 if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
00510 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
00511 { soap_flag_SOAP_ENV__Reason--;
00512 continue;
00513 }
00514 if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00515 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
00516 { soap_flag_SOAP_ENV__Node--;
00517 continue;
00518 }
00519 if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00520 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
00521 { soap_flag_SOAP_ENV__Role--;
00522 continue;
00523 }
00524 if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
00525 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
00526 { soap_flag_SOAP_ENV__Detail--;
00527 continue;
00528 }
00529 if (soap->error == SOAP_TAG_MISMATCH)
00530 soap->error = soap_ignore_element(soap);
00531 if (soap->error == SOAP_NO_TAG)
00532 break;
00533 if (soap->error)
00534 return NULL;
00535 }
00536 if (soap_element_end_in(soap, tag))
00537 return NULL;
00538 }
00539 else
00540 { a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Fault, 0, sizeof(struct SOAP_ENV__Fault), 0, NULL);
00541 if (soap->body && soap_element_end_in(soap, tag))
00542 return NULL;
00543 }
00544 return a;
00545 }
00546
00547 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)
00548 {
00549 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
00550 if (soap_out_SOAP_ENV__Fault(soap, tag?tag:"SOAP-ENV:Fault", id, a, type))
00551 return soap->error;
00552 return soap_putindependent(soap);
00553 }
00554
00555 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)
00556 {
00557 if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
00558 if (soap_getindependent(soap))
00559 return NULL;
00560 return p;
00561 }
00562
00563 #endif
00564
00565 #ifndef WITH_NOGLOBAL
00566
00567 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
00568 {
00569 (void)soap; (void)a;
00570 soap_default_string(soap, &a->SOAP_ENV__Text);
00571 }
00572
00573 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
00574 {
00575 (void)soap; (void)a;
00576 soap_serialize_string(soap, &a->SOAP_ENV__Text);
00577 }
00578
00579 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)
00580 {
00581 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
00582 return soap->error;
00583 if (soap->lang)
00584 soap_set_attr(soap, "xml:lang", soap->lang, 1);
00585 if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
00586 return soap->error;
00587 return soap_element_end_out(soap, tag);
00588 }
00589
00590 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)
00591 {
00592 size_t soap_flag_SOAP_ENV__Text = 1;
00593 if (soap_element_begin_in(soap, tag, 0, type))
00594 return NULL;
00595 a = (struct SOAP_ENV__Reason *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, NULL, NULL, NULL);
00596 if (!a)
00597 return NULL;
00598 soap_default_SOAP_ENV__Reason(soap, a);
00599 if (soap->body && !*soap->href)
00600 {
00601 for (;;)
00602 { soap->error = SOAP_TAG_MISMATCH;
00603 if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00604 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
00605 { soap_flag_SOAP_ENV__Text--;
00606 continue;
00607 }
00608 if (soap->error == SOAP_TAG_MISMATCH)
00609 soap->error = soap_ignore_element(soap);
00610 if (soap->error == SOAP_NO_TAG)
00611 break;
00612 if (soap->error)
00613 return NULL;
00614 }
00615 if (soap_element_end_in(soap, tag))
00616 return NULL;
00617 }
00618 else
00619 { a = (struct SOAP_ENV__Reason *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Reason, 0, sizeof(struct SOAP_ENV__Reason), 0, NULL);
00620 if (soap->body && soap_element_end_in(soap, tag))
00621 return NULL;
00622 }
00623 return a;
00624 }
00625
00626 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)
00627 {
00628 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
00629 if (soap_out_SOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
00630 return soap->error;
00631 return soap_putindependent(soap);
00632 }
00633
00634 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)
00635 {
00636 if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
00637 if (soap_getindependent(soap))
00638 return NULL;
00639 return p;
00640 }
00641
00642 #endif
00643
00644 #ifndef WITH_NOGLOBAL
00645
00646 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
00647 {
00648 (void)soap; (void)a;
00649 a->__any = NULL;
00650 a->__type = 0;
00651 a->fault = NULL;
00652 }
00653
00654 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
00655 {
00656 (void)soap; (void)a;
00657 soap_markelement(soap, a->fault, a->__type);
00658 }
00659
00660 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)
00661 {
00662 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
00663 return soap->error;
00664 soap_outliteral(soap, "-any", &a->__any, NULL);
00665 if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
00666 return soap->error;
00667 return soap_element_end_out(soap, tag);
00668 }
00669
00670 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)
00671 {
00672 size_t soap_flag___any = 1;
00673 size_t soap_flag_fault = 1;
00674 if (soap_element_begin_in(soap, tag, 0, type))
00675 return NULL;
00676 a = (struct SOAP_ENV__Detail *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, NULL, NULL, NULL);
00677 if (!a)
00678 return NULL;
00679 soap_default_SOAP_ENV__Detail(soap, a);
00680 if (soap->body && !*soap->href)
00681 {
00682 for (;;)
00683 { soap->error = SOAP_TAG_MISMATCH;
00684 if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
00685 if ((a->fault = soap_getelement(soap, &a->__type)))
00686 { soap_flag_fault = 0;
00687 continue;
00688 }
00689 if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00690 if (soap_inliteral(soap, "-any", &a->__any))
00691 { soap_flag___any--;
00692 continue;
00693 }
00694 if (soap->error == SOAP_TAG_MISMATCH)
00695 soap->error = soap_ignore_element(soap);
00696 if (soap->error == SOAP_NO_TAG)
00697 break;
00698 if (soap->error)
00699 return NULL;
00700 }
00701 if (soap_element_end_in(soap, tag))
00702 return NULL;
00703 }
00704 else
00705 { a = (struct SOAP_ENV__Detail *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Detail, 0, sizeof(struct SOAP_ENV__Detail), 0, NULL);
00706 if (soap->body && soap_element_end_in(soap, tag))
00707 return NULL;
00708 }
00709 return a;
00710 }
00711
00712 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)
00713 {
00714 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
00715 if (soap_out_SOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
00716 return soap->error;
00717 return soap_putindependent(soap);
00718 }
00719
00720 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)
00721 {
00722 if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
00723 if (soap_getindependent(soap))
00724 return NULL;
00725 return p;
00726 }
00727
00728 #endif
00729
00730 #ifndef WITH_NOGLOBAL
00731
00732 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
00733 {
00734 (void)soap; (void)a;
00735 soap_default__QName(soap, &a->SOAP_ENV__Value);
00736 a->SOAP_ENV__Subcode = NULL;
00737 }
00738
00739 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
00740 {
00741 (void)soap; (void)a;
00742 soap_serialize__QName(soap, &a->SOAP_ENV__Value);
00743 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
00744 }
00745
00746 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)
00747 {
00748 const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
00749 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
00750 return soap->error;
00751 if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
00752 return soap->error;
00753 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
00754 return soap->error;
00755 return soap_element_end_out(soap, tag);
00756 }
00757
00758 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)
00759 {
00760 size_t soap_flag_SOAP_ENV__Value = 1;
00761 size_t soap_flag_SOAP_ENV__Subcode = 1;
00762 if (soap_element_begin_in(soap, tag, 0, type))
00763 return NULL;
00764 a = (struct SOAP_ENV__Code *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, NULL, NULL, NULL);
00765 if (!a)
00766 return NULL;
00767 soap_default_SOAP_ENV__Code(soap, a);
00768 if (soap->body && !*soap->href)
00769 {
00770 for (;;)
00771 { soap->error = SOAP_TAG_MISMATCH;
00772 if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00773 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
00774 { soap_flag_SOAP_ENV__Value--;
00775 continue;
00776 }
00777 if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
00778 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
00779 { soap_flag_SOAP_ENV__Subcode--;
00780 continue;
00781 }
00782 if (soap->error == SOAP_TAG_MISMATCH)
00783 soap->error = soap_ignore_element(soap);
00784 if (soap->error == SOAP_NO_TAG)
00785 break;
00786 if (soap->error)
00787 return NULL;
00788 }
00789 if (soap_element_end_in(soap, tag))
00790 return NULL;
00791 }
00792 else
00793 { a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Code, 0, sizeof(struct SOAP_ENV__Code), 0, NULL);
00794 if (soap->body && soap_element_end_in(soap, tag))
00795 return NULL;
00796 }
00797 return a;
00798 }
00799
00800 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)
00801 {
00802 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
00803 if (soap_out_SOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
00804 return soap->error;
00805 return soap_putindependent(soap);
00806 }
00807
00808 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)
00809 {
00810 if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
00811 if (soap_getindependent(soap))
00812 return NULL;
00813 return p;
00814 }
00815
00816 #endif
00817
00818 #ifndef WITH_NOGLOBAL
00819
00820 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
00821 {
00822 (void)soap; (void)a;
00823 }
00824
00825 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
00826 {
00827 (void)soap; (void)a;
00828 }
00829
00830 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)
00831 {
00832 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
00833 return soap->error;
00834 return soap_element_end_out(soap, tag);
00835 }
00836
00837 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)
00838 {
00839 if (soap_element_begin_in(soap, tag, 0, type))
00840 return NULL;
00841 a = (struct SOAP_ENV__Header *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0, NULL, NULL, NULL);
00842 if (!a)
00843 return NULL;
00844 soap_default_SOAP_ENV__Header(soap, a);
00845 if (soap->body && !*soap->href)
00846 {
00847 for (;;)
00848 { soap->error = SOAP_TAG_MISMATCH;
00849 if (soap->error == SOAP_TAG_MISMATCH)
00850 soap->error = soap_ignore_element(soap);
00851 if (soap->error == SOAP_NO_TAG)
00852 break;
00853 if (soap->error)
00854 return NULL;
00855 }
00856 if (soap_element_end_in(soap, tag))
00857 return NULL;
00858 }
00859 else
00860 { a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Header, 0, sizeof(struct SOAP_ENV__Header), 0, NULL);
00861 if (soap->body && soap_element_end_in(soap, tag))
00862 return NULL;
00863 }
00864 return a;
00865 }
00866
00867 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)
00868 {
00869 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
00870 if (soap_out_SOAP_ENV__Header(soap, tag?tag:"SOAP-ENV:Header", id, a, type))
00871 return soap->error;
00872 return soap_putindependent(soap);
00873 }
00874
00875 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)
00876 {
00877 if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
00878 if (soap_getindependent(soap))
00879 return NULL;
00880 return p;
00881 }
00882
00883 #endif
00884
00885 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__GetQuote(struct soap *soap, struct __ns3__GetQuote *a)
00886 {
00887 (void)soap; (void)a;
00888 a->ns1__GetQuote = NULL;
00889 }
00890
00891 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__GetQuote(struct soap *soap, const struct __ns3__GetQuote *a)
00892 {
00893 (void)soap; (void)a;
00894 soap_serialize_PointerTo_ns1__GetQuote(soap, &a->ns1__GetQuote);
00895 }
00896
00897 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__GetQuote(struct soap *soap, const char *tag, int id, const struct __ns3__GetQuote *a, const char *type)
00898 {
00899 if (soap_out_PointerTo_ns1__GetQuote(soap, "ns1:GetQuote", -1, &a->ns1__GetQuote, ""))
00900 return soap->error;
00901 return SOAP_OK;
00902 }
00903
00904 SOAP_FMAC3 struct __ns3__GetQuote * SOAP_FMAC4 soap_in___ns3__GetQuote(struct soap *soap, const char *tag, struct __ns3__GetQuote *a, const char *type)
00905 {
00906 size_t soap_flag_ns1__GetQuote = 1;
00907 short soap_flag;
00908 a = (struct __ns3__GetQuote *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__GetQuote, sizeof(struct __ns3__GetQuote), 0, NULL, NULL, NULL);
00909 if (!a)
00910 return NULL;
00911 soap_default___ns3__GetQuote(soap, a);
00912 for (soap_flag = 0;; soap_flag = 1)
00913 { soap->error = SOAP_TAG_MISMATCH;
00914 if (soap_flag_ns1__GetQuote && soap->error == SOAP_TAG_MISMATCH)
00915 if (soap_in_PointerTo_ns1__GetQuote(soap, "ns1:GetQuote", &a->ns1__GetQuote, ""))
00916 { soap_flag_ns1__GetQuote--;
00917 continue;
00918 }
00919 if (soap->error == SOAP_TAG_MISMATCH)
00920 if (soap_flag)
00921 { soap->error = SOAP_OK;
00922 break;
00923 }
00924 if (soap_flag && soap->error == SOAP_NO_TAG)
00925 break;
00926 if (soap->error)
00927 return NULL;
00928 }
00929 return a;
00930 }
00931
00932 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__GetQuote(struct soap *soap, const struct __ns3__GetQuote *a, const char *tag, const char *type)
00933 {
00934 register int id = 0;
00935 if (soap_out___ns3__GetQuote(soap, tag?tag:"-ns3:GetQuote", id, a, type))
00936 return soap->error;
00937 return SOAP_OK;
00938 }
00939
00940 SOAP_FMAC3 struct __ns3__GetQuote * SOAP_FMAC4 soap_get___ns3__GetQuote(struct soap *soap, struct __ns3__GetQuote *p, const char *tag, const char *type)
00941 {
00942 if ((p = soap_in___ns3__GetQuote(soap, tag, p, type)))
00943 if (soap_getindependent(soap))
00944 return NULL;
00945 return p;
00946 }
00947
00948 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__GetQuote(struct soap *soap, struct __ns2__GetQuote *a)
00949 {
00950 (void)soap; (void)a;
00951 a->ns1__GetQuote = NULL;
00952 }
00953
00954 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__GetQuote(struct soap *soap, const struct __ns2__GetQuote *a)
00955 {
00956 (void)soap; (void)a;
00957 soap_serialize_PointerTo_ns1__GetQuote(soap, &a->ns1__GetQuote);
00958 }
00959
00960 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__GetQuote(struct soap *soap, const char *tag, int id, const struct __ns2__GetQuote *a, const char *type)
00961 {
00962 if (soap_out_PointerTo_ns1__GetQuote(soap, "ns1:GetQuote", -1, &a->ns1__GetQuote, ""))
00963 return soap->error;
00964 return SOAP_OK;
00965 }
00966
00967 SOAP_FMAC3 struct __ns2__GetQuote * SOAP_FMAC4 soap_in___ns2__GetQuote(struct soap *soap, const char *tag, struct __ns2__GetQuote *a, const char *type)
00968 {
00969 size_t soap_flag_ns1__GetQuote = 1;
00970 short soap_flag;
00971 a = (struct __ns2__GetQuote *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__GetQuote, sizeof(struct __ns2__GetQuote), 0, NULL, NULL, NULL);
00972 if (!a)
00973 return NULL;
00974 soap_default___ns2__GetQuote(soap, a);
00975 for (soap_flag = 0;; soap_flag = 1)
00976 { soap->error = SOAP_TAG_MISMATCH;
00977 if (soap_flag_ns1__GetQuote && soap->error == SOAP_TAG_MISMATCH)
00978 if (soap_in_PointerTo_ns1__GetQuote(soap, "ns1:GetQuote", &a->ns1__GetQuote, ""))
00979 { soap_flag_ns1__GetQuote--;
00980 continue;
00981 }
00982 if (soap->error == SOAP_TAG_MISMATCH)
00983 if (soap_flag)
00984 { soap->error = SOAP_OK;
00985 break;
00986 }
00987 if (soap_flag && soap->error == SOAP_NO_TAG)
00988 break;
00989 if (soap->error)
00990 return NULL;
00991 }
00992 return a;
00993 }
00994
00995 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__GetQuote(struct soap *soap, const struct __ns2__GetQuote *a, const char *tag, const char *type)
00996 {
00997 register int id = 0;
00998 if (soap_out___ns2__GetQuote(soap, tag?tag:"-ns2:GetQuote", id, a, type))
00999 return soap->error;
01000 return SOAP_OK;
01001 }
01002
01003 SOAP_FMAC3 struct __ns2__GetQuote * SOAP_FMAC4 soap_get___ns2__GetQuote(struct soap *soap, struct __ns2__GetQuote *p, const char *tag, const char *type)
01004 {
01005 if ((p = soap_in___ns2__GetQuote(soap, tag, p, type)))
01006 if (soap_getindependent(soap))
01007 return NULL;
01008 return p;
01009 }
01010
01011 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__GetQuoteResponse(struct soap *soap, struct _ns1__GetQuoteResponse *a)
01012 {
01013 (void)soap; (void)a;
01014 soap_default_string(soap, &a->GetQuoteResult);
01015 }
01016
01017 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__GetQuoteResponse(struct soap *soap, const struct _ns1__GetQuoteResponse *a)
01018 {
01019 (void)soap; (void)a;
01020 soap_serialize_string(soap, &a->GetQuoteResult);
01021 }
01022
01023 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__GetQuoteResponse(struct soap *soap, const char *tag, int id, const struct _ns1__GetQuoteResponse *a, const char *type)
01024 {
01025 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__GetQuoteResponse), type))
01026 return soap->error;
01027 if (a->GetQuoteResult)
01028 soap_element_result(soap, "ns1:GetQuoteResult");
01029 if (soap_out_string(soap, "ns1:GetQuoteResult", -1, &a->GetQuoteResult, ""))
01030 return soap->error;
01031 return soap_element_end_out(soap, tag);
01032 }
01033
01034 SOAP_FMAC3 struct _ns1__GetQuoteResponse * SOAP_FMAC4 soap_in__ns1__GetQuoteResponse(struct soap *soap, const char *tag, struct _ns1__GetQuoteResponse *a, const char *type)
01035 {
01036 size_t soap_flag_GetQuoteResult = 1;
01037 if (soap_element_begin_in(soap, tag, 0, type))
01038 return NULL;
01039 a = (struct _ns1__GetQuoteResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__GetQuoteResponse, sizeof(struct _ns1__GetQuoteResponse), 0, NULL, NULL, NULL);
01040 if (!a)
01041 return NULL;
01042 soap_default__ns1__GetQuoteResponse(soap, a);
01043 if (soap->body && !*soap->href)
01044 {
01045 for (;;)
01046 { soap->error = SOAP_TAG_MISMATCH;
01047 if (soap_flag_GetQuoteResult && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01048 if (soap_in_string(soap, "ns1:GetQuoteResult", &a->GetQuoteResult, "xsd:string"))
01049 { soap_flag_GetQuoteResult--;
01050 continue;
01051 }
01052 soap_check_result(soap, "ns1:GetQuoteResult");
01053 if (soap->error == SOAP_TAG_MISMATCH)
01054 soap->error = soap_ignore_element(soap);
01055 if (soap->error == SOAP_NO_TAG)
01056 break;
01057 if (soap->error)
01058 return NULL;
01059 }
01060 if (soap_element_end_in(soap, tag))
01061 return NULL;
01062 }
01063 else
01064 { a = (struct _ns1__GetQuoteResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__GetQuoteResponse, 0, sizeof(struct _ns1__GetQuoteResponse), 0, NULL);
01065 if (soap->body && soap_element_end_in(soap, tag))
01066 return NULL;
01067 }
01068 return a;
01069 }
01070
01071 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__GetQuoteResponse(struct soap *soap, const struct _ns1__GetQuoteResponse *a, const char *tag, const char *type)
01072 {
01073 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__GetQuoteResponse);
01074 if (soap_out__ns1__GetQuoteResponse(soap, tag?tag:"ns1:GetQuoteResponse", id, a, type))
01075 return soap->error;
01076 return soap_putindependent(soap);
01077 }
01078
01079 SOAP_FMAC3 struct _ns1__GetQuoteResponse * SOAP_FMAC4 soap_get__ns1__GetQuoteResponse(struct soap *soap, struct _ns1__GetQuoteResponse *p, const char *tag, const char *type)
01080 {
01081 if ((p = soap_in__ns1__GetQuoteResponse(soap, tag, p, type)))
01082 if (soap_getindependent(soap))
01083 return NULL;
01084 return p;
01085 }
01086
01087 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__GetQuote(struct soap *soap, struct _ns1__GetQuote *a)
01088 {
01089 (void)soap; (void)a;
01090 soap_default_string(soap, &a->symbol);
01091 }
01092
01093 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__GetQuote(struct soap *soap, const struct _ns1__GetQuote *a)
01094 {
01095 (void)soap; (void)a;
01096 soap_serialize_string(soap, &a->symbol);
01097 }
01098
01099 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__GetQuote(struct soap *soap, const char *tag, int id, const struct _ns1__GetQuote *a, const char *type)
01100 {
01101 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__GetQuote), type))
01102 return soap->error;
01103 if (soap_out_string(soap, "ns1:symbol", -1, &a->symbol, ""))
01104 return soap->error;
01105 return soap_element_end_out(soap, tag);
01106 }
01107
01108 SOAP_FMAC3 struct _ns1__GetQuote * SOAP_FMAC4 soap_in__ns1__GetQuote(struct soap *soap, const char *tag, struct _ns1__GetQuote *a, const char *type)
01109 {
01110 size_t soap_flag_symbol = 1;
01111 if (soap_element_begin_in(soap, tag, 0, type))
01112 return NULL;
01113 a = (struct _ns1__GetQuote *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__GetQuote, sizeof(struct _ns1__GetQuote), 0, NULL, NULL, NULL);
01114 if (!a)
01115 return NULL;
01116 soap_default__ns1__GetQuote(soap, a);
01117 if (soap->body && !*soap->href)
01118 {
01119 for (;;)
01120 { soap->error = SOAP_TAG_MISMATCH;
01121 if (soap_flag_symbol && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01122 if (soap_in_string(soap, "ns1:symbol", &a->symbol, "xsd:string"))
01123 { soap_flag_symbol--;
01124 continue;
01125 }
01126 if (soap->error == SOAP_TAG_MISMATCH)
01127 soap->error = soap_ignore_element(soap);
01128 if (soap->error == SOAP_NO_TAG)
01129 break;
01130 if (soap->error)
01131 return NULL;
01132 }
01133 if (soap_element_end_in(soap, tag))
01134 return NULL;
01135 }
01136 else
01137 { a = (struct _ns1__GetQuote *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__GetQuote, 0, sizeof(struct _ns1__GetQuote), 0, NULL);
01138 if (soap->body && soap_element_end_in(soap, tag))
01139 return NULL;
01140 }
01141 return a;
01142 }
01143
01144 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__GetQuote(struct soap *soap, const struct _ns1__GetQuote *a, const char *tag, const char *type)
01145 {
01146 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__GetQuote);
01147 if (soap_out__ns1__GetQuote(soap, tag?tag:"ns1:GetQuote", id, a, type))
01148 return soap->error;
01149 return soap_putindependent(soap);
01150 }
01151
01152 SOAP_FMAC3 struct _ns1__GetQuote * SOAP_FMAC4 soap_get__ns1__GetQuote(struct soap *soap, struct _ns1__GetQuote *p, const char *tag, const char *type)
01153 {
01154 if ((p = soap_in__ns1__GetQuote(soap, tag, p, type)))
01155 if (soap_getindependent(soap))
01156 return NULL;
01157 return p;
01158 }
01159
01160 #ifndef WITH_NOGLOBAL
01161
01162 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
01163 {
01164 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
01165 soap_serialize_SOAP_ENV__Reason(soap, *a);
01166 }
01167
01168 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)
01169 {
01170 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
01171 if (id < 0)
01172 return soap->error;
01173 return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
01174 }
01175
01176 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)
01177 {
01178 if (soap_element_begin_in(soap, tag, 1, NULL))
01179 return NULL;
01180 if (!a)
01181 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
01182 return NULL;
01183 *a = NULL;
01184 if (!soap->null && *soap->href != '#')
01185 { soap_revert(soap);
01186 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
01187 return NULL;
01188 }
01189 else
01190 { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
01191 if (soap->body && soap_element_end_in(soap, tag))
01192 return NULL;
01193 }
01194 return a;
01195 }
01196
01197 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)
01198 {
01199 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
01200 if (soap_out_PointerToSOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
01201 return soap->error;
01202 return soap_putindependent(soap);
01203 }
01204
01205 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)
01206 {
01207 if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
01208 if (soap_getindependent(soap))
01209 return NULL;
01210 return p;
01211 }
01212
01213 #endif
01214
01215 #ifndef WITH_NOGLOBAL
01216
01217 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
01218 {
01219 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
01220 soap_serialize_SOAP_ENV__Detail(soap, *a);
01221 }
01222
01223 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)
01224 {
01225 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
01226 if (id < 0)
01227 return soap->error;
01228 return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
01229 }
01230
01231 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)
01232 {
01233 if (soap_element_begin_in(soap, tag, 1, NULL))
01234 return NULL;
01235 if (!a)
01236 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
01237 return NULL;
01238 *a = NULL;
01239 if (!soap->null && *soap->href != '#')
01240 { soap_revert(soap);
01241 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
01242 return NULL;
01243 }
01244 else
01245 { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
01246 if (soap->body && soap_element_end_in(soap, tag))
01247 return NULL;
01248 }
01249 return a;
01250 }
01251
01252 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)
01253 {
01254 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
01255 if (soap_out_PointerToSOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
01256 return soap->error;
01257 return soap_putindependent(soap);
01258 }
01259
01260 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)
01261 {
01262 if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
01263 if (soap_getindependent(soap))
01264 return NULL;
01265 return p;
01266 }
01267
01268 #endif
01269
01270 #ifndef WITH_NOGLOBAL
01271
01272 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
01273 {
01274 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
01275 soap_serialize_SOAP_ENV__Code(soap, *a);
01276 }
01277
01278 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)
01279 {
01280 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
01281 if (id < 0)
01282 return soap->error;
01283 return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
01284 }
01285
01286 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)
01287 {
01288 if (soap_element_begin_in(soap, tag, 1, NULL))
01289 return NULL;
01290 if (!a)
01291 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
01292 return NULL;
01293 *a = NULL;
01294 if (!soap->null && *soap->href != '#')
01295 { soap_revert(soap);
01296 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
01297 return NULL;
01298 }
01299 else
01300 { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
01301 if (soap->body && soap_element_end_in(soap, tag))
01302 return NULL;
01303 }
01304 return a;
01305 }
01306
01307 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)
01308 {
01309 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
01310 if (soap_out_PointerToSOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
01311 return soap->error;
01312 return soap_putindependent(soap);
01313 }
01314
01315 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)
01316 {
01317 if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
01318 if (soap_getindependent(soap))
01319 return NULL;
01320 return p;
01321 }
01322
01323 #endif
01324
01325 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__GetQuoteResponse(struct soap *soap, struct _ns1__GetQuoteResponse *const*a)
01326 {
01327 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__GetQuoteResponse))
01328 soap_serialize__ns1__GetQuoteResponse(soap, *a);
01329 }
01330
01331 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__GetQuoteResponse(struct soap *soap, const char *tag, int id, struct _ns1__GetQuoteResponse *const*a, const char *type)
01332 {
01333 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__GetQuoteResponse);
01334 if (id < 0)
01335 return soap->error;
01336 return soap_out__ns1__GetQuoteResponse(soap, tag, id, *a, type);
01337 }
01338
01339 SOAP_FMAC3 struct _ns1__GetQuoteResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__GetQuoteResponse(struct soap *soap, const char *tag, struct _ns1__GetQuoteResponse **a, const char *type)
01340 {
01341 if (soap_element_begin_in(soap, tag, 1, NULL))
01342 return NULL;
01343 if (!a)
01344 if (!(a = (struct _ns1__GetQuoteResponse **)soap_malloc(soap, sizeof(struct _ns1__GetQuoteResponse *))))
01345 return NULL;
01346 *a = NULL;
01347 if (!soap->null && *soap->href != '#')
01348 { soap_revert(soap);
01349 if (!(*a = soap_in__ns1__GetQuoteResponse(soap, tag, *a, type)))
01350 return NULL;
01351 }
01352 else
01353 { a = (struct _ns1__GetQuoteResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__GetQuoteResponse, sizeof(struct _ns1__GetQuoteResponse), 0);
01354 if (soap->body && soap_element_end_in(soap, tag))
01355 return NULL;
01356 }
01357 return a;
01358 }
01359
01360 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__GetQuoteResponse(struct soap *soap, struct _ns1__GetQuoteResponse *const*a, const char *tag, const char *type)
01361 {
01362 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__GetQuoteResponse);
01363 if (soap_out_PointerTo_ns1__GetQuoteResponse(soap, tag?tag:"ns1:GetQuoteResponse", id, a, type))
01364 return soap->error;
01365 return soap_putindependent(soap);
01366 }
01367
01368 SOAP_FMAC3 struct _ns1__GetQuoteResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__GetQuoteResponse(struct soap *soap, struct _ns1__GetQuoteResponse **p, const char *tag, const char *type)
01369 {
01370 if ((p = soap_in_PointerTo_ns1__GetQuoteResponse(soap, tag, p, type)))
01371 if (soap_getindependent(soap))
01372 return NULL;
01373 return p;
01374 }
01375
01376 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__GetQuote(struct soap *soap, struct _ns1__GetQuote *const*a)
01377 {
01378 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__GetQuote))
01379 soap_serialize__ns1__GetQuote(soap, *a);
01380 }
01381
01382 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__GetQuote(struct soap *soap, const char *tag, int id, struct _ns1__GetQuote *const*a, const char *type)
01383 {
01384 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__GetQuote);
01385 if (id < 0)
01386 return soap->error;
01387 return soap_out__ns1__GetQuote(soap, tag, id, *a, type);
01388 }
01389
01390 SOAP_FMAC3 struct _ns1__GetQuote ** SOAP_FMAC4 soap_in_PointerTo_ns1__GetQuote(struct soap *soap, const char *tag, struct _ns1__GetQuote **a, const char *type)
01391 {
01392 if (soap_element_begin_in(soap, tag, 1, NULL))
01393 return NULL;
01394 if (!a)
01395 if (!(a = (struct _ns1__GetQuote **)soap_malloc(soap, sizeof(struct _ns1__GetQuote *))))
01396 return NULL;
01397 *a = NULL;
01398 if (!soap->null && *soap->href != '#')
01399 { soap_revert(soap);
01400 if (!(*a = soap_in__ns1__GetQuote(soap, tag, *a, type)))
01401 return NULL;
01402 }
01403 else
01404 { a = (struct _ns1__GetQuote **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__GetQuote, sizeof(struct _ns1__GetQuote), 0);
01405 if (soap->body && soap_element_end_in(soap, tag))
01406 return NULL;
01407 }
01408 return a;
01409 }
01410
01411 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__GetQuote(struct soap *soap, struct _ns1__GetQuote *const*a, const char *tag, const char *type)
01412 {
01413 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__GetQuote);
01414 if (soap_out_PointerTo_ns1__GetQuote(soap, tag?tag:"ns1:GetQuote", id, a, type))
01415 return soap->error;
01416 return soap_putindependent(soap);
01417 }
01418
01419 SOAP_FMAC3 struct _ns1__GetQuote ** SOAP_FMAC4 soap_get_PointerTo_ns1__GetQuote(struct soap *soap, struct _ns1__GetQuote **p, const char *tag, const char *type)
01420 {
01421 if ((p = soap_in_PointerTo_ns1__GetQuote(soap, tag, p, type)))
01422 if (soap_getindependent(soap))
01423 return NULL;
01424 return p;
01425 }
01426
01427 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01428 {
01429 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
01430 }
01431
01432 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
01433 { char **p;
01434 p = soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, 0, -1);
01435 return p;
01436 }
01437
01438 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
01439 {
01440 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
01441 if (soap_out__QName(soap, tag?tag:"byte", id, a, type))
01442 return soap->error;
01443 return soap_putindependent(soap);
01444 }
01445
01446 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
01447 {
01448 if ((p = soap_in__QName(soap, tag, p, type)))
01449 if (soap_getindependent(soap))
01450 return NULL;
01451 return p;
01452 }
01453
01454 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
01455 {
01456 (void)soap;
01457 #ifdef SOAP_DEFAULT_string
01458 *a = SOAP_DEFAULT_string;
01459 #else
01460 *a = (char *)0;
01461 #endif
01462 }
01463
01464 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
01465 {
01466 soap_reference(soap, *a, SOAP_TYPE_string);
01467 }
01468
01469 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01470 {
01471 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
01472 }
01473
01474 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
01475 { char **p;
01476 p = soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, 0, -1);
01477 return p;
01478 }
01479
01480 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
01481 {
01482 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
01483 if (soap_out_string(soap, tag?tag:"byte", id, a, type))
01484 return soap->error;
01485 return soap_putindependent(soap);
01486 }
01487
01488 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
01489 {
01490 if ((p = soap_in_string(soap, tag, p, type)))
01491 if (soap_getindependent(soap))
01492 return NULL;
01493 return p;
01494 }
01495
01496 #ifdef __cplusplus
01497 }
01498 #endif
01499
01500 #if defined(__BORLANDC__)
01501 #pragma option pop
01502 #pragma option pop
01503 #endif
01504
01505