00001
00002
00003
00004
00005
00006
00007
00008 #include "currencyConvertorH.h"
00009
00010 #ifdef __cplusplus
00011 extern "C" {
00012 #endif
00013
00014 SOAP_SOURCE_STAMP("@(#) currencyConvertorC.c ver 2.7.9l 2007-10-12 16:03:36 GMT")
00015
00016
00017 #ifndef WITH_NOGLOBAL
00018
00019 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
00020 {
00021 if (soap->header)
00022 soap_serialize_SOAP_ENV__Header(soap, soap->header);
00023 }
00024
00025 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
00026 {
00027 if (soap->header)
00028 { soap->part = SOAP_IN_HEADER;
00029 if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
00030 return soap->error;
00031 soap->part = SOAP_END_HEADER;
00032 }
00033 return SOAP_OK;
00034 }
00035
00036 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
00037 {
00038 soap->part = SOAP_IN_HEADER;
00039 soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
00040 soap->part = SOAP_END_HEADER;
00041 return soap->header == NULL;
00042 }
00043
00044 SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
00045 {
00046 if (!soap->header)
00047 { soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
00048 soap_default_SOAP_ENV__Header(soap, soap->header);
00049 }
00050 }
00051
00052 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
00053 {
00054 if (!soap->fault)
00055 { soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault));
00056 soap_default_SOAP_ENV__Fault(soap, soap->fault);
00057 }
00058 if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
00059 { soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00060 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
00061 }
00062 if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
00063 { soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason));
00064 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
00065 }
00066 }
00067
00068 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
00069 {
00070 if (soap->fault)
00071 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
00072 }
00073
00074 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
00075 {
00076 if (soap->fault)
00077 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
00078 return SOAP_OK;
00079 }
00080
00081 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
00082 {
00083 return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
00084 }
00085
00086 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
00087 {
00088 soap_fault(soap);
00089 if (soap->version == 2)
00090 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
00091 return (const char**)&soap->fault->faultcode;
00092 }
00093
00094 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
00095 {
00096 soap_fault(soap);
00097 if (soap->version == 2)
00098 { if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
00099 { soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00100 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
00101 }
00102 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
00103 }
00104 return (const char**)&soap->fault->faultcode;
00105 }
00106
00107 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
00108 {
00109 soap_fault(soap);
00110 if (soap->version == 2)
00111 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
00112 return (const char**)&soap->fault->faultstring;
00113 }
00114
00115 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
00116 {
00117 soap_fault(soap);
00118 if (soap->version == 1)
00119 { if (!soap->fault->detail)
00120 { soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00121 soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
00122 }
00123 return (const char**)&soap->fault->detail->__any;
00124 }
00125 if (!soap->fault->SOAP_ENV__Detail)
00126 { soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00127 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
00128 }
00129 return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
00130 }
00131
00132 #endif
00133
00134 #ifndef WITH_NOIDREF
00135 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
00136 {
00137 int t;
00138 for (;;)
00139 if (!soap_getelement(soap, &t))
00140 if (soap->error || soap_ignore_element(soap))
00141 break;
00142 if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
00143 soap->error = SOAP_OK;
00144 return soap->error;
00145 }
00146 #endif
00147
00148 #ifndef WITH_NOIDREF
00149 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
00150 {
00151 if (soap_peek_element(soap))
00152 return NULL;
00153 if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
00154 *type = soap_lookup_type(soap, soap->href);
00155 switch (*type)
00156 {
00157 case SOAP_TYPE_byte:
00158 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
00159 case SOAP_TYPE_int:
00160 return soap_in_int(soap, NULL, NULL, "xsd:int");
00161 case SOAP_TYPE_double:
00162 return soap_in_double(soap, NULL, NULL, "xsd:double");
00163 case SOAP_TYPE_ns1__Currency:
00164 return soap_in_ns1__Currency(soap, NULL, NULL, "ns1:Currency");
00165 case SOAP_TYPE_PointerTo_ns1__ConversionRateResponse:
00166 return soap_in_PointerTo_ns1__ConversionRateResponse(soap, NULL, NULL, "ns1:ConversionRateResponse");
00167 case SOAP_TYPE_PointerTo_ns1__ConversionRate:
00168 return soap_in_PointerTo_ns1__ConversionRate(soap, NULL, NULL, "ns1:ConversionRate");
00169 case SOAP_TYPE_string:
00170 { char **s;
00171 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00172 return s ? *s : NULL;
00173 }
00174 default:
00175 { const char *t = soap->type;
00176 if (!*t)
00177 t = soap->tag;
00178 if (!soap_match_tag(soap, t, "xsd:byte"))
00179 { *type = SOAP_TYPE_byte;
00180 return soap_in_byte(soap, NULL, NULL, NULL);
00181 }
00182 if (!soap_match_tag(soap, t, "xsd:int"))
00183 { *type = SOAP_TYPE_int;
00184 return soap_in_int(soap, NULL, NULL, NULL);
00185 }
00186 if (!soap_match_tag(soap, t, "xsd:double"))
00187 { *type = SOAP_TYPE_double;
00188 return soap_in_double(soap, NULL, NULL, NULL);
00189 }
00190 if (!soap_match_tag(soap, t, "ns1:Currency"))
00191 { *type = SOAP_TYPE_ns1__Currency;
00192 return soap_in_ns1__Currency(soap, NULL, NULL, NULL);
00193 }
00194 if (!soap_match_tag(soap, t, "xsd:string"))
00195 { char **s;
00196 *type = SOAP_TYPE_string;
00197 s = soap_in_string(soap, NULL, NULL, NULL);
00198 return s ? *s : NULL;
00199 }
00200 t = soap->tag;
00201 if (!soap_match_tag(soap, t, "ns1:ConversionRateResponse"))
00202 { *type = SOAP_TYPE__ns1__ConversionRateResponse;
00203 return soap_in__ns1__ConversionRateResponse(soap, NULL, NULL, NULL);
00204 }
00205 if (!soap_match_tag(soap, t, "ns1:ConversionRate"))
00206 { *type = SOAP_TYPE__ns1__ConversionRate;
00207 return soap_in__ns1__ConversionRate(soap, NULL, NULL, NULL);
00208 }
00209 if (!soap_match_tag(soap, t, "xsd:QName"))
00210 { char **s;
00211 *type = SOAP_TYPE__QName;
00212 s = soap_in__QName(soap, NULL, NULL, NULL);
00213 return s ? *s : NULL;
00214 }
00215 }
00216 }
00217 soap->error = SOAP_TAG_MISMATCH;
00218 return NULL;
00219 }
00220 #endif
00221
00222 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00223 {
00224 if (!soap_peek_element(soap))
00225 { int t;
00226 if (soap->mustUnderstand && !soap->other)
00227 return soap->error = SOAP_MUSTUNDERSTAND;
00228 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00229 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00230 return soap->error = SOAP_TAG_MISMATCH;
00231 }
00232 if (!*soap->id || !soap_getelement(soap, &t))
00233 { soap->peeked = 0;
00234 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00235 if (soap->fignore)
00236 soap->error = soap->fignore(soap, soap->tag);
00237 else
00238 soap->error = SOAP_OK;
00239 DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00240 if (!soap->error && soap->body)
00241 { soap->level++;
00242 while (!soap_ignore_element(soap))
00243 ;
00244 if (soap->error == SOAP_NO_TAG)
00245 soap->error = soap_element_end_in(soap, NULL);
00246 }
00247 }
00248 }
00249 return soap->error;
00250 }
00251
00252 #ifndef WITH_NOIDREF
00253 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00254 {
00255 int i;
00256 struct soap_plist *pp;
00257 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00258 for (i = 0; i < SOAP_PTRHASH; i++)
00259 for (pp = soap->pht[i]; pp; pp = pp->next)
00260 if (pp->mark1 == 2 || pp->mark2 == 2)
00261 if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00262 return soap->error;
00263 return SOAP_OK;
00264 }
00265 #endif
00266
00267 #ifndef WITH_NOIDREF
00268 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00269 {
00270 switch (type)
00271 {
00272 case SOAP_TYPE_byte:
00273 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00274 case SOAP_TYPE_int:
00275 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00276 case SOAP_TYPE_double:
00277 return soap_out_double(soap, tag, id, (const double *)ptr, "xsd:double");
00278 case SOAP_TYPE_ns1__Currency:
00279 return soap_out_ns1__Currency(soap, tag, id, (const enum ns1__Currency *)ptr, "ns1:Currency");
00280 case SOAP_TYPE__ns1__ConversionRateResponse:
00281 return soap_out__ns1__ConversionRateResponse(soap, "ns1:ConversionRateResponse", id, (const struct _ns1__ConversionRateResponse *)ptr, NULL);
00282 case SOAP_TYPE__ns1__ConversionRate:
00283 return soap_out__ns1__ConversionRate(soap, "ns1:ConversionRate", id, (const struct _ns1__ConversionRate *)ptr, NULL);
00284 case SOAP_TYPE_PointerTo_ns1__ConversionRateResponse:
00285 return soap_out_PointerTo_ns1__ConversionRateResponse(soap, tag, id, (struct _ns1__ConversionRateResponse *const*)ptr, "ns1:ConversionRateResponse");
00286 case SOAP_TYPE_PointerTo_ns1__ConversionRate:
00287 return soap_out_PointerTo_ns1__ConversionRate(soap, tag, id, (struct _ns1__ConversionRate *const*)ptr, "ns1:ConversionRate");
00288 case SOAP_TYPE__QName:
00289 return soap_out_string(soap, "xsd:QName", id, (char*const*)&ptr, NULL);
00290 case SOAP_TYPE_string:
00291 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
00292 }
00293 return SOAP_OK;
00294 }
00295 #endif
00296
00297 #ifndef WITH_NOIDREF
00298 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00299 {
00300 (void)soap; (void)ptr; (void)type;
00301 switch (type)
00302 {
00303 case SOAP_TYPE___ns1__ConversionRate:
00304 soap_serialize___ns1__ConversionRate(soap, (const struct __ns1__ConversionRate *)ptr);
00305 break;
00306 case SOAP_TYPE__ns1__ConversionRateResponse:
00307 soap_serialize__ns1__ConversionRateResponse(soap, (const struct _ns1__ConversionRateResponse *)ptr);
00308 break;
00309 case SOAP_TYPE__ns1__ConversionRate:
00310 soap_serialize__ns1__ConversionRate(soap, (const struct _ns1__ConversionRate *)ptr);
00311 break;
00312 case SOAP_TYPE_PointerTo_ns1__ConversionRateResponse:
00313 soap_serialize_PointerTo_ns1__ConversionRateResponse(soap, (struct _ns1__ConversionRateResponse *const*)ptr);
00314 break;
00315 case SOAP_TYPE_PointerTo_ns1__ConversionRate:
00316 soap_serialize_PointerTo_ns1__ConversionRate(soap, (struct _ns1__ConversionRate *const*)ptr);
00317 break;
00318 case SOAP_TYPE__QName:
00319 soap_serialize_string(soap, (char*const*)&ptr);
00320 break;
00321 case SOAP_TYPE_string:
00322 soap_serialize_string(soap, (char*const*)&ptr);
00323 break;
00324 }
00325 }
00326 #endif
00327
00328 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00329 { (void)soap;
00330 #ifdef SOAP_DEFAULT_byte
00331 *a = SOAP_DEFAULT_byte;
00332 #else
00333 *a = (char)0;
00334 #endif
00335 }
00336
00337 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00338 {
00339 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00340 if (soap_out_byte(soap, tag, id, a, type))
00341 return soap->error;
00342 return soap_putindependent(soap);
00343 }
00344
00345 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00346 {
00347 return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00348 }
00349
00350 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00351 {
00352 if ((p = soap_in_byte(soap, tag, p, type)))
00353 if (soap_getindependent(soap))
00354 return NULL;
00355 return p;
00356 }
00357
00358 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00359 {
00360 return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00361 }
00362
00363 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00364 { (void)soap;
00365 #ifdef SOAP_DEFAULT_int
00366 *a = SOAP_DEFAULT_int;
00367 #else
00368 *a = (int)0;
00369 #endif
00370 }
00371
00372 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00373 {
00374 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00375 if (soap_out_int(soap, tag, id, a, type))
00376 return soap->error;
00377 return soap_putindependent(soap);
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_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00386 {
00387 if ((p = soap_in_int(soap, tag, p, type)))
00388 if (soap_getindependent(soap))
00389 return NULL;
00390 return p;
00391 }
00392
00393 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00394 {
00395 return soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00396 }
00397
00398 SOAP_FMAC3 void SOAP_FMAC4 soap_default_double(struct soap *soap, double *a)
00399 { (void)soap;
00400 #ifdef SOAP_DEFAULT_double
00401 *a = SOAP_DEFAULT_double;
00402 #else
00403 *a = (double)0;
00404 #endif
00405 }
00406
00407 SOAP_FMAC3 int SOAP_FMAC4 soap_put_double(struct soap *soap, const double *a, const char *tag, const char *type)
00408 {
00409 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_double);
00410 if (soap_out_double(soap, tag, id, a, type))
00411 return soap->error;
00412 return soap_putindependent(soap);
00413 }
00414
00415 SOAP_FMAC3 int SOAP_FMAC4 soap_out_double(struct soap *soap, const char *tag, int id, const double *a, const char *type)
00416 {
00417 return soap_outdouble(soap, tag, id, a, type, SOAP_TYPE_double);
00418 }
00419
00420 SOAP_FMAC3 double * SOAP_FMAC4 soap_get_double(struct soap *soap, double *p, const char *tag, const char *type)
00421 {
00422 if ((p = soap_in_double(soap, tag, p, type)))
00423 if (soap_getindependent(soap))
00424 return NULL;
00425 return p;
00426 }
00427
00428 SOAP_FMAC3 double * SOAP_FMAC4 soap_in_double(struct soap *soap, const char *tag, double *a, const char *type)
00429 {
00430 return soap_indouble(soap, tag, a, type, SOAP_TYPE_double);
00431 }
00432
00433 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__Currency(struct soap *soap, enum ns1__Currency *a)
00434 { (void)soap;
00435 #ifdef SOAP_DEFAULT_ns1__Currency
00436 *a = SOAP_DEFAULT_ns1__Currency;
00437 #else
00438 *a = (enum ns1__Currency)0;
00439 #endif
00440 }
00441
00442 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__Currency(struct soap *soap, const enum ns1__Currency *a, const char *tag, const char *type)
00443 {
00444 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__Currency);
00445 if (soap_out_ns1__Currency(soap, tag, id, a, type))
00446 return soap->error;
00447 return soap_putindependent(soap);
00448 }
00449
00450 static const struct soap_code_map soap_codes_ns1__Currency[] =
00451 { { (long)ns1__Currency__AFA, "AFA" },
00452 { (long)ns1__Currency__ALL, "ALL" },
00453 { (long)ns1__Currency__DZD, "DZD" },
00454 { (long)ns1__Currency__ARS, "ARS" },
00455 { (long)ns1__Currency__AWG, "AWG" },
00456 { (long)ns1__Currency__AUD, "AUD" },
00457 { (long)ns1__Currency__BSD, "BSD" },
00458 { (long)ns1__Currency__BHD, "BHD" },
00459 { (long)ns1__Currency__BDT, "BDT" },
00460 { (long)ns1__Currency__BBD, "BBD" },
00461 { (long)ns1__Currency__BZD, "BZD" },
00462 { (long)ns1__Currency__BMD, "BMD" },
00463 { (long)ns1__Currency__BTN, "BTN" },
00464 { (long)ns1__Currency__BOB, "BOB" },
00465 { (long)ns1__Currency__BWP, "BWP" },
00466 { (long)ns1__Currency__BRL, "BRL" },
00467 { (long)ns1__Currency__GBP, "GBP" },
00468 { (long)ns1__Currency__BND, "BND" },
00469 { (long)ns1__Currency__BIF, "BIF" },
00470 { (long)ns1__Currency__XOF, "XOF" },
00471 { (long)ns1__Currency__XAF, "XAF" },
00472 { (long)ns1__Currency__KHR, "KHR" },
00473 { (long)ns1__Currency__CAD, "CAD" },
00474 { (long)ns1__Currency__CVE, "CVE" },
00475 { (long)ns1__Currency__KYD, "KYD" },
00476 { (long)ns1__Currency__CLP, "CLP" },
00477 { (long)ns1__Currency__CNY, "CNY" },
00478 { (long)ns1__Currency__COP, "COP" },
00479 { (long)ns1__Currency__KMF, "KMF" },
00480 { (long)ns1__Currency__CRC, "CRC" },
00481 { (long)ns1__Currency__HRK, "HRK" },
00482 { (long)ns1__Currency__CUP, "CUP" },
00483 { (long)ns1__Currency__CYP, "CYP" },
00484 { (long)ns1__Currency__CZK, "CZK" },
00485 { (long)ns1__Currency__DKK, "DKK" },
00486 { (long)ns1__Currency__DJF, "DJF" },
00487 { (long)ns1__Currency__DOP, "DOP" },
00488 { (long)ns1__Currency__XCD, "XCD" },
00489 { (long)ns1__Currency__EGP, "EGP" },
00490 { (long)ns1__Currency__SVC, "SVC" },
00491 { (long)ns1__Currency__EEK, "EEK" },
00492 { (long)ns1__Currency__ETB, "ETB" },
00493 { (long)ns1__Currency__EUR, "EUR" },
00494 { (long)ns1__Currency__FKP, "FKP" },
00495 { (long)ns1__Currency__GMD, "GMD" },
00496 { (long)ns1__Currency__GHC, "GHC" },
00497 { (long)ns1__Currency__GIP, "GIP" },
00498 { (long)ns1__Currency__XAU, "XAU" },
00499 { (long)ns1__Currency__GTQ, "GTQ" },
00500 { (long)ns1__Currency__GNF, "GNF" },
00501 { (long)ns1__Currency__GYD, "GYD" },
00502 { (long)ns1__Currency__HTG, "HTG" },
00503 { (long)ns1__Currency__HNL, "HNL" },
00504 { (long)ns1__Currency__HKD, "HKD" },
00505 { (long)ns1__Currency__HUF, "HUF" },
00506 { (long)ns1__Currency__ISK, "ISK" },
00507 { (long)ns1__Currency__INR, "INR" },
00508 { (long)ns1__Currency__IDR, "IDR" },
00509 { (long)ns1__Currency__IQD, "IQD" },
00510 { (long)ns1__Currency__ILS, "ILS" },
00511 { (long)ns1__Currency__JMD, "JMD" },
00512 { (long)ns1__Currency__JPY, "JPY" },
00513 { (long)ns1__Currency__JOD, "JOD" },
00514 { (long)ns1__Currency__KZT, "KZT" },
00515 { (long)ns1__Currency__KES, "KES" },
00516 { (long)ns1__Currency__KRW, "KRW" },
00517 { (long)ns1__Currency__KWD, "KWD" },
00518 { (long)ns1__Currency__LAK, "LAK" },
00519 { (long)ns1__Currency__LVL, "LVL" },
00520 { (long)ns1__Currency__LBP, "LBP" },
00521 { (long)ns1__Currency__LSL, "LSL" },
00522 { (long)ns1__Currency__LRD, "LRD" },
00523 { (long)ns1__Currency__LYD, "LYD" },
00524 { (long)ns1__Currency__LTL, "LTL" },
00525 { (long)ns1__Currency__MOP, "MOP" },
00526 { (long)ns1__Currency__MKD, "MKD" },
00527 { (long)ns1__Currency__MGF, "MGF" },
00528 { (long)ns1__Currency__MWK, "MWK" },
00529 { (long)ns1__Currency__MYR, "MYR" },
00530 { (long)ns1__Currency__MVR, "MVR" },
00531 { (long)ns1__Currency__MTL, "MTL" },
00532 { (long)ns1__Currency__MRO, "MRO" },
00533 { (long)ns1__Currency__MUR, "MUR" },
00534 { (long)ns1__Currency__MXN, "MXN" },
00535 { (long)ns1__Currency__MDL, "MDL" },
00536 { (long)ns1__Currency__MNT, "MNT" },
00537 { (long)ns1__Currency__MAD, "MAD" },
00538 { (long)ns1__Currency__MZM, "MZM" },
00539 { (long)ns1__Currency__MMK, "MMK" },
00540 { (long)ns1__Currency__NAD, "NAD" },
00541 { (long)ns1__Currency__NPR, "NPR" },
00542 { (long)ns1__Currency__ANG, "ANG" },
00543 { (long)ns1__Currency__NZD, "NZD" },
00544 { (long)ns1__Currency__NIO, "NIO" },
00545 { (long)ns1__Currency__NGN, "NGN" },
00546 { (long)ns1__Currency__KPW, "KPW" },
00547 { (long)ns1__Currency__NOK, "NOK" },
00548 { (long)ns1__Currency__OMR, "OMR" },
00549 { (long)ns1__Currency__XPF, "XPF" },
00550 { (long)ns1__Currency__PKR, "PKR" },
00551 { (long)ns1__Currency__XPD, "XPD" },
00552 { (long)ns1__Currency__PAB, "PAB" },
00553 { (long)ns1__Currency__PGK, "PGK" },
00554 { (long)ns1__Currency__PYG, "PYG" },
00555 { (long)ns1__Currency__PEN, "PEN" },
00556 { (long)ns1__Currency__PHP, "PHP" },
00557 { (long)ns1__Currency__XPT, "XPT" },
00558 { (long)ns1__Currency__PLN, "PLN" },
00559 { (long)ns1__Currency__QAR, "QAR" },
00560 { (long)ns1__Currency__ROL, "ROL" },
00561 { (long)ns1__Currency__RUB, "RUB" },
00562 { (long)ns1__Currency__WST, "WST" },
00563 { (long)ns1__Currency__STD, "STD" },
00564 { (long)ns1__Currency__SAR, "SAR" },
00565 { (long)ns1__Currency__SCR, "SCR" },
00566 { (long)ns1__Currency__SLL, "SLL" },
00567 { (long)ns1__Currency__XAG, "XAG" },
00568 { (long)ns1__Currency__SGD, "SGD" },
00569 { (long)ns1__Currency__SKK, "SKK" },
00570 { (long)ns1__Currency__SIT, "SIT" },
00571 { (long)ns1__Currency__SBD, "SBD" },
00572 { (long)ns1__Currency__SOS, "SOS" },
00573 { (long)ns1__Currency__ZAR, "ZAR" },
00574 { (long)ns1__Currency__LKR, "LKR" },
00575 { (long)ns1__Currency__SHP, "SHP" },
00576 { (long)ns1__Currency__SDD, "SDD" },
00577 { (long)ns1__Currency__SRG, "SRG" },
00578 { (long)ns1__Currency__SZL, "SZL" },
00579 { (long)ns1__Currency__SEK, "SEK" },
00580 { (long)ns1__Currency__CHF, "CHF" },
00581 { (long)ns1__Currency__SYP, "SYP" },
00582 { (long)ns1__Currency__TWD, "TWD" },
00583 { (long)ns1__Currency__TZS, "TZS" },
00584 { (long)ns1__Currency__THB, "THB" },
00585 { (long)ns1__Currency__TOP, "TOP" },
00586 { (long)ns1__Currency__TTD, "TTD" },
00587 { (long)ns1__Currency__TND, "TND" },
00588 { (long)ns1__Currency__TRL, "TRL" },
00589 { (long)ns1__Currency__USD, "USD" },
00590 { (long)ns1__Currency__AED, "AED" },
00591 { (long)ns1__Currency__UGX, "UGX" },
00592 { (long)ns1__Currency__UAH, "UAH" },
00593 { (long)ns1__Currency__UYU, "UYU" },
00594 { (long)ns1__Currency__VUV, "VUV" },
00595 { (long)ns1__Currency__VEB, "VEB" },
00596 { (long)ns1__Currency__VND, "VND" },
00597 { (long)ns1__Currency__YER, "YER" },
00598 { (long)ns1__Currency__YUM, "YUM" },
00599 { (long)ns1__Currency__ZMK, "ZMK" },
00600 { (long)ns1__Currency__ZWD, "ZWD" },
00601 { (long)ns1__Currency__TRY, "TRY" },
00602 { 0, NULL }
00603 };
00604
00605 SOAP_FMAC3S const char* SOAP_FMAC4S soap_ns1__Currency2s(struct soap *soap, enum ns1__Currency n)
00606 { const char *s = soap_code_str(soap_codes_ns1__Currency, (long)n);
00607 if (s)
00608 return s;
00609 return soap_long2s(soap, (long)n);
00610 }
00611
00612 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__Currency(struct soap *soap, const char *tag, int id, const enum ns1__Currency *a, const char *type)
00613 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__Currency), type) || soap_send(soap, soap_ns1__Currency2s(soap, *a)))
00614 return soap->error;
00615 return soap_element_end_out(soap, tag);
00616 }
00617
00618 SOAP_FMAC3 enum ns1__Currency * SOAP_FMAC4 soap_get_ns1__Currency(struct soap *soap, enum ns1__Currency *p, const char *tag, const char *type)
00619 {
00620 if ((p = soap_in_ns1__Currency(soap, tag, p, type)))
00621 if (soap_getindependent(soap))
00622 return NULL;
00623 return p;
00624 }
00625
00626 SOAP_FMAC3S int SOAP_FMAC4S soap_s2ns1__Currency(struct soap *soap, const char *s, enum ns1__Currency *a)
00627 {
00628 const struct soap_code_map *map;
00629 if (!s)
00630 return SOAP_OK;
00631 map = soap_code(soap_codes_ns1__Currency, s);
00632 if (map)
00633 *a = (enum ns1__Currency)map->code;
00634 else
00635 { long n;
00636 if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 150)))
00637 return soap->error = SOAP_TYPE;
00638 *a = (enum ns1__Currency)n;
00639 }
00640 return SOAP_OK;
00641 }
00642
00643 SOAP_FMAC3 enum ns1__Currency * SOAP_FMAC4 soap_in_ns1__Currency(struct soap *soap, const char *tag, enum ns1__Currency *a, const char *type)
00644 {
00645 if (soap_element_begin_in(soap, tag, 0, type))
00646 return NULL;
00647 a = (enum ns1__Currency *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__Currency, sizeof(enum ns1__Currency), 0, NULL, NULL, NULL);
00648 if (!a)
00649 return NULL;
00650 if (soap->body && !*soap->href)
00651 { if (!a || soap_s2ns1__Currency(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
00652 return NULL;
00653 }
00654 else
00655 { a = (enum ns1__Currency *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__Currency, 0, sizeof(enum ns1__Currency), 0, NULL);
00656 if (soap->body && soap_element_end_in(soap, tag))
00657 return NULL;
00658 }
00659 return a;
00660 }
00661
00662 #ifndef WITH_NOGLOBAL
00663
00664 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
00665 {
00666 (void)soap; (void)a;
00667 soap_default__QName(soap, &a->faultcode);
00668 soap_default_string(soap, &a->faultstring);
00669 soap_default_string(soap, &a->faultactor);
00670 a->detail = NULL;
00671 a->SOAP_ENV__Code = NULL;
00672 a->SOAP_ENV__Reason = NULL;
00673 soap_default_string(soap, &a->SOAP_ENV__Node);
00674 soap_default_string(soap, &a->SOAP_ENV__Role);
00675 a->SOAP_ENV__Detail = NULL;
00676 }
00677
00678 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
00679 {
00680 (void)soap; (void)a;
00681 soap_serialize__QName(soap, &a->faultcode);
00682 soap_serialize_string(soap, &a->faultstring);
00683 soap_serialize_string(soap, &a->faultactor);
00684 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
00685 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
00686 soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
00687 soap_serialize_string(soap, &a->SOAP_ENV__Node);
00688 soap_serialize_string(soap, &a->SOAP_ENV__Role);
00689 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
00690 }
00691
00692 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)
00693 {
00694 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
00695 if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type))
00696 return soap->error;
00697 return soap_putindependent(soap);
00698 }
00699
00700 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)
00701 {
00702 const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
00703 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
00704 return soap->error;
00705 if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
00706 return soap->error;
00707 if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
00708 return soap->error;
00709 if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
00710 return soap->error;
00711 if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
00712 return soap->error;
00713 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
00714 return soap->error;
00715 if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
00716 return soap->error;
00717 if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
00718 return soap->error;
00719 if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
00720 return soap->error;
00721 if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
00722 return soap->error;
00723 return soap_element_end_out(soap, tag);
00724 }
00725
00726 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)
00727 {
00728 if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
00729 if (soap_getindependent(soap))
00730 return NULL;
00731 return p;
00732 }
00733
00734 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)
00735 {
00736 short soap_flag_faultcode = 1, soap_flag_faultstring = 1, soap_flag_faultactor = 1, soap_flag_detail = 1, soap_flag_SOAP_ENV__Code = 1, soap_flag_SOAP_ENV__Reason = 1, soap_flag_SOAP_ENV__Node = 1, soap_flag_SOAP_ENV__Role = 1, soap_flag_SOAP_ENV__Detail = 1;
00737 if (soap_element_begin_in(soap, tag, 0, type))
00738 return NULL;
00739 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);
00740 if (!a)
00741 return NULL;
00742 soap_default_SOAP_ENV__Fault(soap, a);
00743 if (soap->body && !*soap->href)
00744 {
00745 for (;;)
00746 { soap->error = SOAP_TAG_MISMATCH;
00747 if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00748 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
00749 { soap_flag_faultcode--;
00750 continue;
00751 }
00752 if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00753 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
00754 { soap_flag_faultstring--;
00755 continue;
00756 }
00757 if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00758 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
00759 { soap_flag_faultactor--;
00760 continue;
00761 }
00762 if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
00763 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
00764 { soap_flag_detail--;
00765 continue;
00766 }
00767 if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
00768 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
00769 { soap_flag_SOAP_ENV__Code--;
00770 continue;
00771 }
00772 if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
00773 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
00774 { soap_flag_SOAP_ENV__Reason--;
00775 continue;
00776 }
00777 if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00778 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
00779 { soap_flag_SOAP_ENV__Node--;
00780 continue;
00781 }
00782 if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00783 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
00784 { soap_flag_SOAP_ENV__Role--;
00785 continue;
00786 }
00787 if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
00788 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
00789 { soap_flag_SOAP_ENV__Detail--;
00790 continue;
00791 }
00792 if (soap->error == SOAP_TAG_MISMATCH)
00793 soap->error = soap_ignore_element(soap);
00794 if (soap->error == SOAP_NO_TAG)
00795 break;
00796 if (soap->error)
00797 return NULL;
00798 }
00799 if (soap_element_end_in(soap, tag))
00800 return NULL;
00801 }
00802 else
00803 { 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);
00804 if (soap->body && soap_element_end_in(soap, tag))
00805 return NULL;
00806 }
00807 return a;
00808 }
00809
00810 #endif
00811
00812 #ifndef WITH_NOGLOBAL
00813
00814 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
00815 {
00816 (void)soap; (void)a;
00817 soap_default_string(soap, &a->SOAP_ENV__Text);
00818 }
00819
00820 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
00821 {
00822 (void)soap; (void)a;
00823 soap_serialize_string(soap, &a->SOAP_ENV__Text);
00824 }
00825
00826 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)
00827 {
00828 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
00829 if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type))
00830 return soap->error;
00831 return soap_putindependent(soap);
00832 }
00833
00834 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)
00835 {
00836 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
00837 return soap->error;
00838 if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
00839 return soap->error;
00840 return soap_element_end_out(soap, tag);
00841 }
00842
00843 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)
00844 {
00845 if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
00846 if (soap_getindependent(soap))
00847 return NULL;
00848 return p;
00849 }
00850
00851 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)
00852 {
00853 short soap_flag_SOAP_ENV__Text = 1;
00854 if (soap_element_begin_in(soap, tag, 0, type))
00855 return NULL;
00856 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);
00857 if (!a)
00858 return NULL;
00859 soap_default_SOAP_ENV__Reason(soap, a);
00860 if (soap->body && !*soap->href)
00861 {
00862 for (;;)
00863 { soap->error = SOAP_TAG_MISMATCH;
00864 if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00865 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
00866 { soap_flag_SOAP_ENV__Text--;
00867 continue;
00868 }
00869 if (soap->error == SOAP_TAG_MISMATCH)
00870 soap->error = soap_ignore_element(soap);
00871 if (soap->error == SOAP_NO_TAG)
00872 break;
00873 if (soap->error)
00874 return NULL;
00875 }
00876 if (soap_element_end_in(soap, tag))
00877 return NULL;
00878 }
00879 else
00880 { 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);
00881 if (soap->body && soap_element_end_in(soap, tag))
00882 return NULL;
00883 }
00884 return a;
00885 }
00886
00887 #endif
00888
00889 #ifndef WITH_NOGLOBAL
00890
00891 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
00892 {
00893 (void)soap; (void)a;
00894 a->__type = 0;
00895 a->fault = NULL;
00896 a->__any = NULL;
00897 }
00898
00899 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
00900 {
00901 (void)soap; (void)a;
00902 soap_markelement(soap, a->fault, a->__type);
00903 }
00904
00905 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)
00906 {
00907 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
00908 if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type))
00909 return soap->error;
00910 return soap_putindependent(soap);
00911 }
00912
00913 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)
00914 {
00915 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
00916 return soap->error;
00917 if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
00918 return soap->error;
00919 soap_outliteral(soap, "-any", &a->__any, NULL);
00920 return soap_element_end_out(soap, tag);
00921 }
00922
00923 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)
00924 {
00925 if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
00926 if (soap_getindependent(soap))
00927 return NULL;
00928 return p;
00929 }
00930
00931 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)
00932 {
00933 short soap_flag_fault = 1, soap_flag___any = 1;
00934 if (soap_element_begin_in(soap, tag, 0, type))
00935 return NULL;
00936 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);
00937 if (!a)
00938 return NULL;
00939 soap_default_SOAP_ENV__Detail(soap, a);
00940 if (soap->body && !*soap->href)
00941 {
00942 for (;;)
00943 { soap->error = SOAP_TAG_MISMATCH;
00944 if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
00945 if ((a->fault = soap_getelement(soap, &a->__type)))
00946 { soap_flag_fault = 0;
00947 continue;
00948 }
00949 if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00950 if (soap_inliteral(soap, "-any", &a->__any))
00951 { soap_flag___any--;
00952 continue;
00953 }
00954 if (soap->error == SOAP_TAG_MISMATCH)
00955 soap->error = soap_ignore_element(soap);
00956 if (soap->error == SOAP_NO_TAG)
00957 break;
00958 if (soap->error)
00959 return NULL;
00960 }
00961 if (soap_element_end_in(soap, tag))
00962 return NULL;
00963 }
00964 else
00965 { 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);
00966 if (soap->body && soap_element_end_in(soap, tag))
00967 return NULL;
00968 }
00969 return a;
00970 }
00971
00972 #endif
00973
00974 #ifndef WITH_NOGLOBAL
00975
00976 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
00977 {
00978 (void)soap; (void)a;
00979 soap_default__QName(soap, &a->SOAP_ENV__Value);
00980 a->SOAP_ENV__Subcode = NULL;
00981 }
00982
00983 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
00984 {
00985 (void)soap; (void)a;
00986 soap_serialize__QName(soap, &a->SOAP_ENV__Value);
00987 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
00988 }
00989
00990 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)
00991 {
00992 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
00993 if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type))
00994 return soap->error;
00995 return soap_putindependent(soap);
00996 }
00997
00998 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)
00999 {
01000 const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
01001 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
01002 return soap->error;
01003 if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
01004 return soap->error;
01005 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
01006 return soap->error;
01007 return soap_element_end_out(soap, tag);
01008 }
01009
01010 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)
01011 {
01012 if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
01013 if (soap_getindependent(soap))
01014 return NULL;
01015 return p;
01016 }
01017
01018 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)
01019 {
01020 short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1;
01021 if (soap_element_begin_in(soap, tag, 0, type))
01022 return NULL;
01023 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);
01024 if (!a)
01025 return NULL;
01026 soap_default_SOAP_ENV__Code(soap, a);
01027 if (soap->body && !*soap->href)
01028 {
01029 for (;;)
01030 { soap->error = SOAP_TAG_MISMATCH;
01031 if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01032 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
01033 { soap_flag_SOAP_ENV__Value--;
01034 continue;
01035 }
01036 if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
01037 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
01038 { soap_flag_SOAP_ENV__Subcode--;
01039 continue;
01040 }
01041 if (soap->error == SOAP_TAG_MISMATCH)
01042 soap->error = soap_ignore_element(soap);
01043 if (soap->error == SOAP_NO_TAG)
01044 break;
01045 if (soap->error)
01046 return NULL;
01047 }
01048 if (soap_element_end_in(soap, tag))
01049 return NULL;
01050 }
01051 else
01052 { 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);
01053 if (soap->body && soap_element_end_in(soap, tag))
01054 return NULL;
01055 }
01056 return a;
01057 }
01058
01059 #endif
01060
01061 #ifndef WITH_NOGLOBAL
01062
01063 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
01064 {
01065 (void)soap; (void)a;
01066 }
01067
01068 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
01069 {
01070 (void)soap; (void)a;
01071 }
01072
01073 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)
01074 {
01075 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
01076 if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type))
01077 return soap->error;
01078 return soap_putindependent(soap);
01079 }
01080
01081 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)
01082 {
01083 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
01084 return soap->error;
01085 return soap_element_end_out(soap, tag);
01086 }
01087
01088 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)
01089 {
01090 if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
01091 if (soap_getindependent(soap))
01092 return NULL;
01093 return p;
01094 }
01095
01096 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)
01097 {
01098 if (soap_element_begin_in(soap, tag, 0, type))
01099 return NULL;
01100 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);
01101 if (!a)
01102 return NULL;
01103 soap_default_SOAP_ENV__Header(soap, a);
01104 if (soap->body && !*soap->href)
01105 {
01106 for (;;)
01107 { soap->error = SOAP_TAG_MISMATCH;
01108 if (soap->error == SOAP_TAG_MISMATCH)
01109 soap->error = soap_ignore_element(soap);
01110 if (soap->error == SOAP_NO_TAG)
01111 break;
01112 if (soap->error)
01113 return NULL;
01114 }
01115 if (soap_element_end_in(soap, tag))
01116 return NULL;
01117 }
01118 else
01119 { 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);
01120 if (soap->body && soap_element_end_in(soap, tag))
01121 return NULL;
01122 }
01123 return a;
01124 }
01125
01126 #endif
01127
01128 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns1__ConversionRate(struct soap *soap, struct __ns1__ConversionRate *a)
01129 {
01130 (void)soap; (void)a;
01131 a->ns1__ConversionRate = NULL;
01132 }
01133
01134 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns1__ConversionRate(struct soap *soap, const struct __ns1__ConversionRate *a)
01135 {
01136 (void)soap; (void)a;
01137 soap_serialize_PointerTo_ns1__ConversionRate(soap, &a->ns1__ConversionRate);
01138 }
01139
01140 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns1__ConversionRate(struct soap *soap, const struct __ns1__ConversionRate *a, const char *tag, const char *type)
01141 {
01142 register int id = 0;
01143 if (soap_out___ns1__ConversionRate(soap, tag, id, a, type))
01144 return soap->error;
01145 return SOAP_OK;
01146 }
01147
01148 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns1__ConversionRate(struct soap *soap, const char *tag, int id, const struct __ns1__ConversionRate *a, const char *type)
01149 {
01150 if (soap_out_PointerTo_ns1__ConversionRate(soap, "ns1:ConversionRate", -1, &a->ns1__ConversionRate, ""))
01151 return soap->error;
01152 return SOAP_OK;
01153 }
01154
01155 SOAP_FMAC3 struct __ns1__ConversionRate * SOAP_FMAC4 soap_get___ns1__ConversionRate(struct soap *soap, struct __ns1__ConversionRate *p, const char *tag, const char *type)
01156 {
01157 if ((p = soap_in___ns1__ConversionRate(soap, tag, p, type)))
01158 if (soap_getindependent(soap))
01159 return NULL;
01160 return p;
01161 }
01162
01163 SOAP_FMAC3 struct __ns1__ConversionRate * SOAP_FMAC4 soap_in___ns1__ConversionRate(struct soap *soap, const char *tag, struct __ns1__ConversionRate *a, const char *type)
01164 {
01165 short soap_flag_ns1__ConversionRate = 1;
01166 short soap_flag;
01167 a = (struct __ns1__ConversionRate *)soap_id_enter(soap, "", a, SOAP_TYPE___ns1__ConversionRate, sizeof(struct __ns1__ConversionRate), 0, NULL, NULL, NULL);
01168 if (!a)
01169 return NULL;
01170 soap_default___ns1__ConversionRate(soap, a);
01171 for (soap_flag = 0;; soap_flag = 1)
01172 { soap->error = SOAP_TAG_MISMATCH;
01173 if (soap_flag_ns1__ConversionRate && soap->error == SOAP_TAG_MISMATCH)
01174 if (soap_in_PointerTo_ns1__ConversionRate(soap, "ns1:ConversionRate", &a->ns1__ConversionRate, ""))
01175 { soap_flag_ns1__ConversionRate--;
01176 continue;
01177 }
01178 if (soap->error == SOAP_TAG_MISMATCH)
01179 if (soap_flag)
01180 { soap->error = SOAP_OK;
01181 break;
01182 }
01183 if (soap->error == SOAP_NO_TAG)
01184 break;
01185 if (soap->error)
01186 return NULL;
01187 }
01188 return a;
01189 }
01190
01191 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ConversionRateResponse(struct soap *soap, struct _ns1__ConversionRateResponse *a)
01192 {
01193 (void)soap; (void)a;
01194 soap_default_double(soap, &a->ConversionRateResult);
01195 }
01196
01197 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ConversionRateResponse(struct soap *soap, const struct _ns1__ConversionRateResponse *a)
01198 {
01199 (void)soap; (void)a;
01200 }
01201
01202 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ConversionRateResponse(struct soap *soap, const struct _ns1__ConversionRateResponse *a, const char *tag, const char *type)
01203 {
01204 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ConversionRateResponse);
01205 if (soap_out__ns1__ConversionRateResponse(soap, tag, id, a, type))
01206 return soap->error;
01207 return soap_putindependent(soap);
01208 }
01209
01210 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ConversionRateResponse(struct soap *soap, const char *tag, int id, const struct _ns1__ConversionRateResponse *a, const char *type)
01211 {
01212 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ConversionRateResponse), type))
01213 return soap->error;
01214 soap_element_result(soap, "ns1:ConversionRateResult");
01215 if (soap_out_double(soap, "ns1:ConversionRateResult", -1, &a->ConversionRateResult, ""))
01216 return soap->error;
01217 return soap_element_end_out(soap, tag);
01218 }
01219
01220 SOAP_FMAC3 struct _ns1__ConversionRateResponse * SOAP_FMAC4 soap_get__ns1__ConversionRateResponse(struct soap *soap, struct _ns1__ConversionRateResponse *p, const char *tag, const char *type)
01221 {
01222 if ((p = soap_in__ns1__ConversionRateResponse(soap, tag, p, type)))
01223 if (soap_getindependent(soap))
01224 return NULL;
01225 return p;
01226 }
01227
01228 SOAP_FMAC3 struct _ns1__ConversionRateResponse * SOAP_FMAC4 soap_in__ns1__ConversionRateResponse(struct soap *soap, const char *tag, struct _ns1__ConversionRateResponse *a, const char *type)
01229 {
01230 short soap_flag_ConversionRateResult = 1;
01231 if (soap_element_begin_in(soap, tag, 0, type))
01232 return NULL;
01233 a = (struct _ns1__ConversionRateResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ConversionRateResponse, sizeof(struct _ns1__ConversionRateResponse), 0, NULL, NULL, NULL);
01234 if (!a)
01235 return NULL;
01236 soap_default__ns1__ConversionRateResponse(soap, a);
01237 if (soap->body && !*soap->href)
01238 {
01239 for (;;)
01240 { soap->error = SOAP_TAG_MISMATCH;
01241 if (soap_flag_ConversionRateResult && soap->error == SOAP_TAG_MISMATCH)
01242 if (soap_in_double(soap, "ns1:ConversionRateResult", &a->ConversionRateResult, "xsd:double"))
01243 { soap_flag_ConversionRateResult--;
01244 continue;
01245 }
01246 soap_check_result(soap, "ns1:ConversionRateResult");
01247 if (soap->error == SOAP_TAG_MISMATCH)
01248 soap->error = soap_ignore_element(soap);
01249 if (soap->error == SOAP_NO_TAG)
01250 break;
01251 if (soap->error)
01252 return NULL;
01253 }
01254 if (soap_element_end_in(soap, tag))
01255 return NULL;
01256 }
01257 else
01258 { a = (struct _ns1__ConversionRateResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ConversionRateResponse, 0, sizeof(struct _ns1__ConversionRateResponse), 0, NULL);
01259 if (soap->body && soap_element_end_in(soap, tag))
01260 return NULL;
01261 }
01262 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ConversionRateResult > 0))
01263 { soap->error = SOAP_OCCURS;
01264 return NULL;
01265 }
01266 return a;
01267 }
01268
01269 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ConversionRate(struct soap *soap, struct _ns1__ConversionRate *a)
01270 {
01271 (void)soap; (void)a;
01272 soap_default_ns1__Currency(soap, &a->FromCurrency);
01273 soap_default_ns1__Currency(soap, &a->ToCurrency);
01274 }
01275
01276 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ConversionRate(struct soap *soap, const struct _ns1__ConversionRate *a)
01277 {
01278 (void)soap; (void)a;
01279 }
01280
01281 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ConversionRate(struct soap *soap, const struct _ns1__ConversionRate *a, const char *tag, const char *type)
01282 {
01283 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ConversionRate);
01284 if (soap_out__ns1__ConversionRate(soap, tag, id, a, type))
01285 return soap->error;
01286 return soap_putindependent(soap);
01287 }
01288
01289 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ConversionRate(struct soap *soap, const char *tag, int id, const struct _ns1__ConversionRate *a, const char *type)
01290 {
01291 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ConversionRate), type))
01292 return soap->error;
01293 if (soap_out_ns1__Currency(soap, "ns1:FromCurrency", -1, &a->FromCurrency, ""))
01294 return soap->error;
01295 if (soap_out_ns1__Currency(soap, "ns1:ToCurrency", -1, &a->ToCurrency, ""))
01296 return soap->error;
01297 return soap_element_end_out(soap, tag);
01298 }
01299
01300 SOAP_FMAC3 struct _ns1__ConversionRate * SOAP_FMAC4 soap_get__ns1__ConversionRate(struct soap *soap, struct _ns1__ConversionRate *p, const char *tag, const char *type)
01301 {
01302 if ((p = soap_in__ns1__ConversionRate(soap, tag, p, type)))
01303 if (soap_getindependent(soap))
01304 return NULL;
01305 return p;
01306 }
01307
01308 SOAP_FMAC3 struct _ns1__ConversionRate * SOAP_FMAC4 soap_in__ns1__ConversionRate(struct soap *soap, const char *tag, struct _ns1__ConversionRate *a, const char *type)
01309 {
01310 short soap_flag_FromCurrency = 1, soap_flag_ToCurrency = 1;
01311 if (soap_element_begin_in(soap, tag, 0, type))
01312 return NULL;
01313 a = (struct _ns1__ConversionRate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ConversionRate, sizeof(struct _ns1__ConversionRate), 0, NULL, NULL, NULL);
01314 if (!a)
01315 return NULL;
01316 soap_default__ns1__ConversionRate(soap, a);
01317 if (soap->body && !*soap->href)
01318 {
01319 for (;;)
01320 { soap->error = SOAP_TAG_MISMATCH;
01321 if (soap_flag_FromCurrency && soap->error == SOAP_TAG_MISMATCH)
01322 if (soap_in_ns1__Currency(soap, "ns1:FromCurrency", &a->FromCurrency, "ns1:Currency"))
01323 { soap_flag_FromCurrency--;
01324 continue;
01325 }
01326 if (soap_flag_ToCurrency && soap->error == SOAP_TAG_MISMATCH)
01327 if (soap_in_ns1__Currency(soap, "ns1:ToCurrency", &a->ToCurrency, "ns1:Currency"))
01328 { soap_flag_ToCurrency--;
01329 continue;
01330 }
01331 if (soap->error == SOAP_TAG_MISMATCH)
01332 soap->error = soap_ignore_element(soap);
01333 if (soap->error == SOAP_NO_TAG)
01334 break;
01335 if (soap->error)
01336 return NULL;
01337 }
01338 if (soap_element_end_in(soap, tag))
01339 return NULL;
01340 }
01341 else
01342 { a = (struct _ns1__ConversionRate *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ConversionRate, 0, sizeof(struct _ns1__ConversionRate), 0, NULL);
01343 if (soap->body && soap_element_end_in(soap, tag))
01344 return NULL;
01345 }
01346 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_FromCurrency > 0 || soap_flag_ToCurrency > 0))
01347 { soap->error = SOAP_OCCURS;
01348 return NULL;
01349 }
01350 return a;
01351 }
01352
01353 #ifndef WITH_NOGLOBAL
01354
01355 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
01356 {
01357 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
01358 soap_serialize_SOAP_ENV__Reason(soap, *a);
01359 }
01360
01361 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)
01362 {
01363 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
01364 if (soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, a, type))
01365 return soap->error;
01366 return soap_putindependent(soap);
01367 }
01368
01369 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)
01370 {
01371 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
01372 if (id < 0)
01373 return soap->error;
01374 return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
01375 }
01376
01377 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)
01378 {
01379 if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
01380 if (soap_getindependent(soap))
01381 return NULL;
01382 return p;
01383 }
01384
01385 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)
01386 {
01387 if (soap_element_begin_in(soap, tag, 1, NULL))
01388 return NULL;
01389 if (!a)
01390 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
01391 return NULL;
01392 *a = NULL;
01393 if (!soap->null && *soap->href != '#')
01394 { soap_revert(soap);
01395 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
01396 return NULL;
01397 }
01398 else
01399 { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
01400 if (soap->body && soap_element_end_in(soap, tag))
01401 return NULL;
01402 }
01403 return a;
01404 }
01405
01406 #endif
01407
01408 #ifndef WITH_NOGLOBAL
01409
01410 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
01411 {
01412 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
01413 soap_serialize_SOAP_ENV__Detail(soap, *a);
01414 }
01415
01416 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)
01417 {
01418 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
01419 if (soap_out_PointerToSOAP_ENV__Detail(soap, tag, id, a, type))
01420 return soap->error;
01421 return soap_putindependent(soap);
01422 }
01423
01424 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)
01425 {
01426 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
01427 if (id < 0)
01428 return soap->error;
01429 return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
01430 }
01431
01432 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)
01433 {
01434 if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
01435 if (soap_getindependent(soap))
01436 return NULL;
01437 return p;
01438 }
01439
01440 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)
01441 {
01442 if (soap_element_begin_in(soap, tag, 1, NULL))
01443 return NULL;
01444 if (!a)
01445 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
01446 return NULL;
01447 *a = NULL;
01448 if (!soap->null && *soap->href != '#')
01449 { soap_revert(soap);
01450 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
01451 return NULL;
01452 }
01453 else
01454 { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
01455 if (soap->body && soap_element_end_in(soap, tag))
01456 return NULL;
01457 }
01458 return a;
01459 }
01460
01461 #endif
01462
01463 #ifndef WITH_NOGLOBAL
01464
01465 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
01466 {
01467 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
01468 soap_serialize_SOAP_ENV__Code(soap, *a);
01469 }
01470
01471 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)
01472 {
01473 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
01474 if (soap_out_PointerToSOAP_ENV__Code(soap, tag, id, a, type))
01475 return soap->error;
01476 return soap_putindependent(soap);
01477 }
01478
01479 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)
01480 {
01481 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
01482 if (id < 0)
01483 return soap->error;
01484 return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
01485 }
01486
01487 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)
01488 {
01489 if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
01490 if (soap_getindependent(soap))
01491 return NULL;
01492 return p;
01493 }
01494
01495 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)
01496 {
01497 if (soap_element_begin_in(soap, tag, 1, NULL))
01498 return NULL;
01499 if (!a)
01500 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
01501 return NULL;
01502 *a = NULL;
01503 if (!soap->null && *soap->href != '#')
01504 { soap_revert(soap);
01505 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
01506 return NULL;
01507 }
01508 else
01509 { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
01510 if (soap->body && soap_element_end_in(soap, tag))
01511 return NULL;
01512 }
01513 return a;
01514 }
01515
01516 #endif
01517
01518 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ConversionRateResponse(struct soap *soap, struct _ns1__ConversionRateResponse *const*a)
01519 {
01520 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ConversionRateResponse))
01521 soap_serialize__ns1__ConversionRateResponse(soap, *a);
01522 }
01523
01524 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ConversionRateResponse(struct soap *soap, struct _ns1__ConversionRateResponse *const*a, const char *tag, const char *type)
01525 {
01526 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ConversionRateResponse);
01527 if (soap_out_PointerTo_ns1__ConversionRateResponse(soap, tag, id, a, type))
01528 return soap->error;
01529 return soap_putindependent(soap);
01530 }
01531
01532 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ConversionRateResponse(struct soap *soap, const char *tag, int id, struct _ns1__ConversionRateResponse *const*a, const char *type)
01533 {
01534 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ConversionRateResponse);
01535 if (id < 0)
01536 return soap->error;
01537 return soap_out__ns1__ConversionRateResponse(soap, tag, id, *a, type);
01538 }
01539
01540 SOAP_FMAC3 struct _ns1__ConversionRateResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__ConversionRateResponse(struct soap *soap, struct _ns1__ConversionRateResponse **p, const char *tag, const char *type)
01541 {
01542 if ((p = soap_in_PointerTo_ns1__ConversionRateResponse(soap, tag, p, type)))
01543 if (soap_getindependent(soap))
01544 return NULL;
01545 return p;
01546 }
01547
01548 SOAP_FMAC3 struct _ns1__ConversionRateResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__ConversionRateResponse(struct soap *soap, const char *tag, struct _ns1__ConversionRateResponse **a, const char *type)
01549 {
01550 if (soap_element_begin_in(soap, tag, 1, NULL))
01551 return NULL;
01552 if (!a)
01553 if (!(a = (struct _ns1__ConversionRateResponse **)soap_malloc(soap, sizeof(struct _ns1__ConversionRateResponse *))))
01554 return NULL;
01555 *a = NULL;
01556 if (!soap->null && *soap->href != '#')
01557 { soap_revert(soap);
01558 if (!(*a = soap_in__ns1__ConversionRateResponse(soap, tag, *a, type)))
01559 return NULL;
01560 }
01561 else
01562 { a = (struct _ns1__ConversionRateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ConversionRateResponse, sizeof(struct _ns1__ConversionRateResponse), 0);
01563 if (soap->body && soap_element_end_in(soap, tag))
01564 return NULL;
01565 }
01566 return a;
01567 }
01568
01569 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ConversionRate(struct soap *soap, struct _ns1__ConversionRate *const*a)
01570 {
01571 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ConversionRate))
01572 soap_serialize__ns1__ConversionRate(soap, *a);
01573 }
01574
01575 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ConversionRate(struct soap *soap, struct _ns1__ConversionRate *const*a, const char *tag, const char *type)
01576 {
01577 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ConversionRate);
01578 if (soap_out_PointerTo_ns1__ConversionRate(soap, tag, id, a, type))
01579 return soap->error;
01580 return soap_putindependent(soap);
01581 }
01582
01583 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ConversionRate(struct soap *soap, const char *tag, int id, struct _ns1__ConversionRate *const*a, const char *type)
01584 {
01585 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ConversionRate);
01586 if (id < 0)
01587 return soap->error;
01588 return soap_out__ns1__ConversionRate(soap, tag, id, *a, type);
01589 }
01590
01591 SOAP_FMAC3 struct _ns1__ConversionRate ** SOAP_FMAC4 soap_get_PointerTo_ns1__ConversionRate(struct soap *soap, struct _ns1__ConversionRate **p, const char *tag, const char *type)
01592 {
01593 if ((p = soap_in_PointerTo_ns1__ConversionRate(soap, tag, p, type)))
01594 if (soap_getindependent(soap))
01595 return NULL;
01596 return p;
01597 }
01598
01599 SOAP_FMAC3 struct _ns1__ConversionRate ** SOAP_FMAC4 soap_in_PointerTo_ns1__ConversionRate(struct soap *soap, const char *tag, struct _ns1__ConversionRate **a, const char *type)
01600 {
01601 if (soap_element_begin_in(soap, tag, 1, NULL))
01602 return NULL;
01603 if (!a)
01604 if (!(a = (struct _ns1__ConversionRate **)soap_malloc(soap, sizeof(struct _ns1__ConversionRate *))))
01605 return NULL;
01606 *a = NULL;
01607 if (!soap->null && *soap->href != '#')
01608 { soap_revert(soap);
01609 if (!(*a = soap_in__ns1__ConversionRate(soap, tag, *a, type)))
01610 return NULL;
01611 }
01612 else
01613 { a = (struct _ns1__ConversionRate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ConversionRate, sizeof(struct _ns1__ConversionRate), 0);
01614 if (soap->body && soap_element_end_in(soap, tag))
01615 return NULL;
01616 }
01617 return a;
01618 }
01619
01620 SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap *soap, char **a)
01621 { soap_default_string(soap, a);
01622 }
01623
01624 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a)
01625 { soap_serialize_string(soap, a);
01626 }
01627
01628 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
01629 {
01630 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
01631 if (soap_out__QName(soap, tag, id, a, type))
01632 return soap->error;
01633 return soap_putindependent(soap);
01634 }
01635
01636 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01637 {
01638 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
01639 }
01640
01641 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
01642 {
01643 if ((p = soap_in__QName(soap, tag, p, type)))
01644 if (soap_getindependent(soap))
01645 return NULL;
01646 return p;
01647 }
01648
01649 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
01650 {
01651 return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1);
01652 }
01653
01654 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
01655 { (void)soap;
01656 #ifdef SOAP_DEFAULT_string
01657 *a = SOAP_DEFAULT_string;
01658 #else
01659 *a = (char *)0;
01660 #endif
01661 }
01662
01663 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
01664 {
01665 soap_reference(soap, *a, SOAP_TYPE_string);
01666 }
01667
01668 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
01669 {
01670 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
01671 if (soap_out_string(soap, tag, id, a, type))
01672 return soap->error;
01673 return soap_putindependent(soap);
01674 }
01675
01676 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01677 {
01678 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
01679 }
01680
01681 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
01682 {
01683 if ((p = soap_in_string(soap, tag, p, type)))
01684 if (soap_getindependent(soap))
01685 return NULL;
01686 return p;
01687 }
01688
01689 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
01690 {
01691 return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1);
01692 }
01693
01694 #ifdef __cplusplus
01695 }
01696 #endif
01697
01698