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 "envH.h"
00017
00018 #ifdef __cplusplus
00019 extern "C" {
00020 #endif
00021
00022 SOAP_SOURCE_STAMP("@(#) envC.c ver 2.8.3 2011-08-08 15:52:31 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__QName:
00175 { char **s;
00176 s = soap_in__QName(soap, NULL, NULL, "xsd:QName");
00177 return s ? *s : NULL;
00178 }
00179 case SOAP_TYPE_string:
00180 { char **s;
00181 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00182 return s ? *s : NULL;
00183 }
00184 default:
00185 { const char *t = soap->type;
00186 if (!*t)
00187 t = soap->tag;
00188 if (!soap_match_tag(soap, t, "xsd:byte"))
00189 { *type = SOAP_TYPE_byte;
00190 return soap_in_byte(soap, NULL, NULL, NULL);
00191 }
00192 if (!soap_match_tag(soap, t, "xsd:int"))
00193 { *type = SOAP_TYPE_int;
00194 return soap_in_int(soap, NULL, NULL, NULL);
00195 }
00196 if (!soap_match_tag(soap, t, "xsd:QName"))
00197 { char **s;
00198 *type = SOAP_TYPE__QName;
00199 s = soap_in__QName(soap, NULL, NULL, NULL);
00200 return s ? *s : NULL;
00201 }
00202 if (!soap_match_tag(soap, t, "xsd:string"))
00203 { char **s;
00204 *type = SOAP_TYPE_string;
00205 s = soap_in_string(soap, NULL, NULL, NULL);
00206 return s ? *s : NULL;
00207 }
00208 t = soap->tag;
00209 }
00210 }
00211 soap->error = SOAP_TAG_MISMATCH;
00212 return NULL;
00213 }
00214 #endif
00215
00216 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00217 {
00218 if (!soap_peek_element(soap))
00219 { int t;
00220 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unexpected element '%s' in input (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00221 if (soap->mustUnderstand && !soap->other)
00222 return soap->error = SOAP_MUSTUNDERSTAND;
00223 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00224 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00225 return soap->error = SOAP_TAG_MISMATCH;
00226 }
00227 if (!*soap->id || !soap_getelement(soap, &t))
00228 { soap->peeked = 0;
00229 if (soap->fignore)
00230 soap->error = soap->fignore(soap, soap->tag);
00231 else
00232 soap->error = SOAP_OK;
00233 DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00234 if (!soap->error && soap->body)
00235 { soap->level++;
00236 while (!soap_ignore_element(soap))
00237 ;
00238 if (soap->error == SOAP_NO_TAG)
00239 soap->error = soap_element_end_in(soap, NULL);
00240 }
00241 }
00242 }
00243 return soap->error;
00244 }
00245
00246 #ifndef WITH_NOIDREF
00247 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00248 {
00249 int i;
00250 struct soap_plist *pp;
00251 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00252 for (i = 0; i < SOAP_PTRHASH; i++)
00253 for (pp = soap->pht[i]; pp; pp = pp->next)
00254 if (pp->mark1 == 2 || pp->mark2 == 2)
00255 if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00256 return soap->error;
00257 return SOAP_OK;
00258 }
00259 #endif
00260
00261 #ifndef WITH_NOIDREF
00262 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00263 {
00264 switch (type)
00265 {
00266 case SOAP_TYPE_byte:
00267 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00268 case SOAP_TYPE_int:
00269 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00270 case SOAP_TYPE__QName:
00271 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:QName");
00272 case SOAP_TYPE_string:
00273 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
00274 }
00275 return SOAP_OK;
00276 }
00277 #endif
00278
00279 #ifndef WITH_NOIDREF
00280 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00281 {
00282 (void)soap; (void)ptr; (void)type;
00283 switch (type)
00284 {
00285 case SOAP_TYPE__QName:
00286 soap_serialize_string(soap, (char*const*)&ptr);
00287 break;
00288 case SOAP_TYPE_string:
00289 soap_serialize_string(soap, (char*const*)&ptr);
00290 break;
00291 }
00292 }
00293 #endif
00294
00295 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00296 {
00297 (void)soap;
00298 #ifdef SOAP_DEFAULT_byte
00299 *a = SOAP_DEFAULT_byte;
00300 #else
00301 *a = (char)0;
00302 #endif
00303 }
00304
00305 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00306 {
00307 return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00308 }
00309
00310 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00311 { char *p;
00312 p = soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00313 return p;
00314 }
00315
00316 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00317 {
00318 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00319 if (soap_out_byte(soap, tag?tag:"byte", id, a, type))
00320 return soap->error;
00321 return soap_putindependent(soap);
00322 }
00323
00324 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00325 {
00326 if ((p = soap_in_byte(soap, tag, p, type)))
00327 if (soap_getindependent(soap))
00328 return NULL;
00329 return p;
00330 }
00331
00332 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00333 {
00334 (void)soap;
00335 #ifdef SOAP_DEFAULT_int
00336 *a = SOAP_DEFAULT_int;
00337 #else
00338 *a = (int)0;
00339 #endif
00340 }
00341
00342 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
00343 {
00344 return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
00345 }
00346
00347 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00348 { int *p;
00349 p = soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00350 return p;
00351 }
00352
00353 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00354 {
00355 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00356 if (soap_out_int(soap, tag?tag:"int", id, a, type))
00357 return soap->error;
00358 return soap_putindependent(soap);
00359 }
00360
00361 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00362 {
00363 if ((p = soap_in_int(soap, tag, p, type)))
00364 if (soap_getindependent(soap))
00365 return NULL;
00366 return p;
00367 }
00368
00369 #ifndef WITH_NOGLOBAL
00370
00371 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
00372 {
00373 (void)soap; (void)a;
00374 soap_default__QName(soap, &a->faultcode);
00375 soap_default_string(soap, &a->faultstring);
00376 soap_default_string(soap, &a->faultactor);
00377 a->detail = NULL;
00378 a->SOAP_ENV__Code = NULL;
00379 a->SOAP_ENV__Reason = NULL;
00380 soap_default_string(soap, &a->SOAP_ENV__Node);
00381 soap_default_string(soap, &a->SOAP_ENV__Role);
00382 a->SOAP_ENV__Detail = NULL;
00383 }
00384
00385 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
00386 {
00387 (void)soap; (void)a;
00388 soap_serialize__QName(soap, &a->faultcode);
00389 soap_serialize_string(soap, &a->faultstring);
00390 soap_serialize_string(soap, &a->faultactor);
00391 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
00392 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
00393 soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
00394 soap_serialize_string(soap, &a->SOAP_ENV__Node);
00395 soap_serialize_string(soap, &a->SOAP_ENV__Role);
00396 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
00397 }
00398
00399 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)
00400 {
00401 const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
00402 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
00403 return soap->error;
00404 if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
00405 return soap->error;
00406 if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
00407 return soap->error;
00408 if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
00409 return soap->error;
00410 if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
00411 return soap->error;
00412 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
00413 return soap->error;
00414 if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
00415 return soap->error;
00416 if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
00417 return soap->error;
00418 if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
00419 return soap->error;
00420 if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
00421 return soap->error;
00422 return soap_element_end_out(soap, tag);
00423 }
00424
00425 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)
00426 {
00427 size_t soap_flag_faultcode = 1;
00428 size_t soap_flag_faultstring = 1;
00429 size_t soap_flag_faultactor = 1;
00430 size_t soap_flag_detail = 1;
00431 size_t soap_flag_SOAP_ENV__Code = 1;
00432 size_t soap_flag_SOAP_ENV__Reason = 1;
00433 size_t soap_flag_SOAP_ENV__Node = 1;
00434 size_t soap_flag_SOAP_ENV__Role = 1;
00435 size_t soap_flag_SOAP_ENV__Detail = 1;
00436 if (soap_element_begin_in(soap, tag, 0, type))
00437 return NULL;
00438 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);
00439 if (!a)
00440 return NULL;
00441 soap_default_SOAP_ENV__Fault(soap, a);
00442 if (soap->body && !*soap->href)
00443 {
00444 for (;;)
00445 { soap->error = SOAP_TAG_MISMATCH;
00446 if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00447 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
00448 { soap_flag_faultcode--;
00449 continue;
00450 }
00451 if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00452 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
00453 { soap_flag_faultstring--;
00454 continue;
00455 }
00456 if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00457 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
00458 { soap_flag_faultactor--;
00459 continue;
00460 }
00461 if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
00462 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
00463 { soap_flag_detail--;
00464 continue;
00465 }
00466 if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
00467 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
00468 { soap_flag_SOAP_ENV__Code--;
00469 continue;
00470 }
00471 if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
00472 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
00473 { soap_flag_SOAP_ENV__Reason--;
00474 continue;
00475 }
00476 if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00477 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
00478 { soap_flag_SOAP_ENV__Node--;
00479 continue;
00480 }
00481 if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00482 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
00483 { soap_flag_SOAP_ENV__Role--;
00484 continue;
00485 }
00486 if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
00487 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
00488 { soap_flag_SOAP_ENV__Detail--;
00489 continue;
00490 }
00491 if (soap->error == SOAP_TAG_MISMATCH)
00492 soap->error = soap_ignore_element(soap);
00493 if (soap->error == SOAP_NO_TAG)
00494 break;
00495 if (soap->error)
00496 return NULL;
00497 }
00498 if (soap_element_end_in(soap, tag))
00499 return NULL;
00500 }
00501 else
00502 { 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);
00503 if (soap->body && soap_element_end_in(soap, tag))
00504 return NULL;
00505 }
00506 return a;
00507 }
00508
00509 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)
00510 {
00511 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
00512 if (soap_out_SOAP_ENV__Fault(soap, tag?tag:"SOAP-ENV:Fault", id, a, type))
00513 return soap->error;
00514 return soap_putindependent(soap);
00515 }
00516
00517 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)
00518 {
00519 if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
00520 if (soap_getindependent(soap))
00521 return NULL;
00522 return p;
00523 }
00524
00525 #endif
00526
00527 #ifndef WITH_NOGLOBAL
00528
00529 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
00530 {
00531 (void)soap; (void)a;
00532 soap_default_string(soap, &a->SOAP_ENV__Text);
00533 }
00534
00535 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
00536 {
00537 (void)soap; (void)a;
00538 soap_serialize_string(soap, &a->SOAP_ENV__Text);
00539 }
00540
00541 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)
00542 {
00543 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
00544 return soap->error;
00545 if (soap->lang)
00546 soap_set_attr(soap, "xml:lang", soap->lang, 1);
00547 if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
00548 return soap->error;
00549 return soap_element_end_out(soap, tag);
00550 }
00551
00552 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)
00553 {
00554 size_t soap_flag_SOAP_ENV__Text = 1;
00555 if (soap_element_begin_in(soap, tag, 0, type))
00556 return NULL;
00557 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);
00558 if (!a)
00559 return NULL;
00560 soap_default_SOAP_ENV__Reason(soap, a);
00561 if (soap->body && !*soap->href)
00562 {
00563 for (;;)
00564 { soap->error = SOAP_TAG_MISMATCH;
00565 if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00566 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
00567 { soap_flag_SOAP_ENV__Text--;
00568 continue;
00569 }
00570 if (soap->error == SOAP_TAG_MISMATCH)
00571 soap->error = soap_ignore_element(soap);
00572 if (soap->error == SOAP_NO_TAG)
00573 break;
00574 if (soap->error)
00575 return NULL;
00576 }
00577 if (soap_element_end_in(soap, tag))
00578 return NULL;
00579 }
00580 else
00581 { 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);
00582 if (soap->body && soap_element_end_in(soap, tag))
00583 return NULL;
00584 }
00585 return a;
00586 }
00587
00588 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)
00589 {
00590 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
00591 if (soap_out_SOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
00592 return soap->error;
00593 return soap_putindependent(soap);
00594 }
00595
00596 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)
00597 {
00598 if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
00599 if (soap_getindependent(soap))
00600 return NULL;
00601 return p;
00602 }
00603
00604 #endif
00605
00606 #ifndef WITH_NOGLOBAL
00607
00608 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
00609 {
00610 (void)soap; (void)a;
00611 a->__any = NULL;
00612 a->__type = 0;
00613 a->fault = NULL;
00614 }
00615
00616 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
00617 {
00618 (void)soap; (void)a;
00619 soap_markelement(soap, a->fault, a->__type);
00620 }
00621
00622 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)
00623 {
00624 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
00625 return soap->error;
00626 soap_outliteral(soap, "-any", &a->__any, NULL);
00627 if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
00628 return soap->error;
00629 return soap_element_end_out(soap, tag);
00630 }
00631
00632 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)
00633 {
00634 size_t soap_flag___any = 1;
00635 size_t soap_flag_fault = 1;
00636 if (soap_element_begin_in(soap, tag, 0, type))
00637 return NULL;
00638 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);
00639 if (!a)
00640 return NULL;
00641 soap_default_SOAP_ENV__Detail(soap, a);
00642 if (soap->body && !*soap->href)
00643 {
00644 for (;;)
00645 { soap->error = SOAP_TAG_MISMATCH;
00646 if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
00647 if ((a->fault = soap_getelement(soap, &a->__type)))
00648 { soap_flag_fault = 0;
00649 continue;
00650 }
00651 if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00652 if (soap_inliteral(soap, "-any", &a->__any))
00653 { soap_flag___any--;
00654 continue;
00655 }
00656 if (soap->error == SOAP_TAG_MISMATCH)
00657 soap->error = soap_ignore_element(soap);
00658 if (soap->error == SOAP_NO_TAG)
00659 break;
00660 if (soap->error)
00661 return NULL;
00662 }
00663 if (soap_element_end_in(soap, tag))
00664 return NULL;
00665 }
00666 else
00667 { 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);
00668 if (soap->body && soap_element_end_in(soap, tag))
00669 return NULL;
00670 }
00671 return a;
00672 }
00673
00674 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)
00675 {
00676 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
00677 if (soap_out_SOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
00678 return soap->error;
00679 return soap_putindependent(soap);
00680 }
00681
00682 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)
00683 {
00684 if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
00685 if (soap_getindependent(soap))
00686 return NULL;
00687 return p;
00688 }
00689
00690 #endif
00691
00692 #ifndef WITH_NOGLOBAL
00693
00694 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
00695 {
00696 (void)soap; (void)a;
00697 soap_default__QName(soap, &a->SOAP_ENV__Value);
00698 a->SOAP_ENV__Subcode = NULL;
00699 }
00700
00701 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
00702 {
00703 (void)soap; (void)a;
00704 soap_serialize__QName(soap, &a->SOAP_ENV__Value);
00705 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
00706 }
00707
00708 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)
00709 {
00710 const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
00711 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
00712 return soap->error;
00713 if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
00714 return soap->error;
00715 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
00716 return soap->error;
00717 return soap_element_end_out(soap, tag);
00718 }
00719
00720 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)
00721 {
00722 size_t soap_flag_SOAP_ENV__Value = 1;
00723 size_t soap_flag_SOAP_ENV__Subcode = 1;
00724 if (soap_element_begin_in(soap, tag, 0, type))
00725 return NULL;
00726 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);
00727 if (!a)
00728 return NULL;
00729 soap_default_SOAP_ENV__Code(soap, a);
00730 if (soap->body && !*soap->href)
00731 {
00732 for (;;)
00733 { soap->error = SOAP_TAG_MISMATCH;
00734 if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00735 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
00736 { soap_flag_SOAP_ENV__Value--;
00737 continue;
00738 }
00739 if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
00740 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
00741 { soap_flag_SOAP_ENV__Subcode--;
00742 continue;
00743 }
00744 if (soap->error == SOAP_TAG_MISMATCH)
00745 soap->error = soap_ignore_element(soap);
00746 if (soap->error == SOAP_NO_TAG)
00747 break;
00748 if (soap->error)
00749 return NULL;
00750 }
00751 if (soap_element_end_in(soap, tag))
00752 return NULL;
00753 }
00754 else
00755 { 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);
00756 if (soap->body && soap_element_end_in(soap, tag))
00757 return NULL;
00758 }
00759 return a;
00760 }
00761
00762 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)
00763 {
00764 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
00765 if (soap_out_SOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
00766 return soap->error;
00767 return soap_putindependent(soap);
00768 }
00769
00770 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)
00771 {
00772 if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
00773 if (soap_getindependent(soap))
00774 return NULL;
00775 return p;
00776 }
00777
00778 #endif
00779
00780 #ifndef WITH_NOGLOBAL
00781
00782 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
00783 {
00784 (void)soap; (void)a;
00785 }
00786
00787 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
00788 {
00789 (void)soap; (void)a;
00790 }
00791
00792 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)
00793 {
00794 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
00795 return soap->error;
00796 return soap_element_end_out(soap, tag);
00797 }
00798
00799 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)
00800 {
00801 if (soap_element_begin_in(soap, tag, 0, type))
00802 return NULL;
00803 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);
00804 if (!a)
00805 return NULL;
00806 soap_default_SOAP_ENV__Header(soap, a);
00807 if (soap->body && !*soap->href)
00808 {
00809 for (;;)
00810 { soap->error = SOAP_TAG_MISMATCH;
00811 if (soap->error == SOAP_TAG_MISMATCH)
00812 soap->error = soap_ignore_element(soap);
00813 if (soap->error == SOAP_NO_TAG)
00814 break;
00815 if (soap->error)
00816 return NULL;
00817 }
00818 if (soap_element_end_in(soap, tag))
00819 return NULL;
00820 }
00821 else
00822 { 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);
00823 if (soap->body && soap_element_end_in(soap, tag))
00824 return NULL;
00825 }
00826 return a;
00827 }
00828
00829 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)
00830 {
00831 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
00832 if (soap_out_SOAP_ENV__Header(soap, tag?tag:"SOAP-ENV:Header", id, a, type))
00833 return soap->error;
00834 return soap_putindependent(soap);
00835 }
00836
00837 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)
00838 {
00839 if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
00840 if (soap_getindependent(soap))
00841 return NULL;
00842 return p;
00843 }
00844
00845 #endif
00846
00847 #ifndef WITH_NOGLOBAL
00848
00849 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
00850 {
00851 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
00852 soap_serialize_SOAP_ENV__Reason(soap, *a);
00853 }
00854
00855 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)
00856 {
00857 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
00858 if (id < 0)
00859 return soap->error;
00860 return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
00861 }
00862
00863 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)
00864 {
00865 if (soap_element_begin_in(soap, tag, 1, NULL))
00866 return NULL;
00867 if (!a)
00868 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
00869 return NULL;
00870 *a = NULL;
00871 if (!soap->null && *soap->href != '#')
00872 { soap_revert(soap);
00873 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
00874 return NULL;
00875 }
00876 else
00877 { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
00878 if (soap->body && soap_element_end_in(soap, tag))
00879 return NULL;
00880 }
00881 return a;
00882 }
00883
00884 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)
00885 {
00886 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
00887 if (soap_out_PointerToSOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
00888 return soap->error;
00889 return soap_putindependent(soap);
00890 }
00891
00892 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)
00893 {
00894 if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
00895 if (soap_getindependent(soap))
00896 return NULL;
00897 return p;
00898 }
00899
00900 #endif
00901
00902 #ifndef WITH_NOGLOBAL
00903
00904 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
00905 {
00906 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
00907 soap_serialize_SOAP_ENV__Detail(soap, *a);
00908 }
00909
00910 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)
00911 {
00912 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
00913 if (id < 0)
00914 return soap->error;
00915 return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
00916 }
00917
00918 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)
00919 {
00920 if (soap_element_begin_in(soap, tag, 1, NULL))
00921 return NULL;
00922 if (!a)
00923 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
00924 return NULL;
00925 *a = NULL;
00926 if (!soap->null && *soap->href != '#')
00927 { soap_revert(soap);
00928 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
00929 return NULL;
00930 }
00931 else
00932 { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
00933 if (soap->body && soap_element_end_in(soap, tag))
00934 return NULL;
00935 }
00936 return a;
00937 }
00938
00939 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)
00940 {
00941 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
00942 if (soap_out_PointerToSOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
00943 return soap->error;
00944 return soap_putindependent(soap);
00945 }
00946
00947 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)
00948 {
00949 if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
00950 if (soap_getindependent(soap))
00951 return NULL;
00952 return p;
00953 }
00954
00955 #endif
00956
00957 #ifndef WITH_NOGLOBAL
00958
00959 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
00960 {
00961 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
00962 soap_serialize_SOAP_ENV__Code(soap, *a);
00963 }
00964
00965 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)
00966 {
00967 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
00968 if (id < 0)
00969 return soap->error;
00970 return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
00971 }
00972
00973 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)
00974 {
00975 if (soap_element_begin_in(soap, tag, 1, NULL))
00976 return NULL;
00977 if (!a)
00978 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
00979 return NULL;
00980 *a = NULL;
00981 if (!soap->null && *soap->href != '#')
00982 { soap_revert(soap);
00983 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
00984 return NULL;
00985 }
00986 else
00987 { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
00988 if (soap->body && soap_element_end_in(soap, tag))
00989 return NULL;
00990 }
00991 return a;
00992 }
00993
00994 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)
00995 {
00996 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
00997 if (soap_out_PointerToSOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
00998 return soap->error;
00999 return soap_putindependent(soap);
01000 }
01001
01002 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)
01003 {
01004 if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
01005 if (soap_getindependent(soap))
01006 return NULL;
01007 return p;
01008 }
01009
01010 #endif
01011
01012 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01013 {
01014 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
01015 }
01016
01017 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
01018 { char **p;
01019 p = soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, 0, -1);
01020 return p;
01021 }
01022
01023 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
01024 {
01025 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
01026 if (soap_out__QName(soap, tag?tag:"byte", id, a, type))
01027 return soap->error;
01028 return soap_putindependent(soap);
01029 }
01030
01031 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
01032 {
01033 if ((p = soap_in__QName(soap, tag, p, type)))
01034 if (soap_getindependent(soap))
01035 return NULL;
01036 return p;
01037 }
01038
01039 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
01040 {
01041 (void)soap;
01042 #ifdef SOAP_DEFAULT_string
01043 *a = SOAP_DEFAULT_string;
01044 #else
01045 *a = (char *)0;
01046 #endif
01047 }
01048
01049 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
01050 {
01051 soap_reference(soap, *a, SOAP_TYPE_string);
01052 }
01053
01054 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01055 {
01056 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
01057 }
01058
01059 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
01060 { char **p;
01061 p = soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, 0, -1);
01062 return p;
01063 }
01064
01065 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
01066 {
01067 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
01068 if (soap_out_string(soap, tag?tag:"byte", id, a, type))
01069 return soap->error;
01070 return soap_putindependent(soap);
01071 }
01072
01073 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
01074 {
01075 if ((p = soap_in_string(soap, tag, p, type)))
01076 if (soap_getindependent(soap))
01077 return NULL;
01078 return p;
01079 }
01080
01081 #ifdef __cplusplus
01082 }
01083 #endif
01084
01085 #if defined(__BORLANDC__)
01086 #pragma option pop
01087 #pragma option pop
01088 #endif
01089
01090