00001
00002
00003
00004
00005
00006
00007
00008 #include "ip2locationH.h"
00009
00010 #ifdef __cplusplus
00011 extern "C" {
00012 #endif
00013
00014 SOAP_SOURCE_STAMP("@(#) ip2locationC.c ver 2.7.9l 2007-10-11 17:54:47 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_float:
00162 return soap_in_float(soap, NULL, NULL, "xsd:float");
00163 case SOAP_TYPE_ns1__IP2LOCATION:
00164 return soap_in_ns1__IP2LOCATION(soap, NULL, NULL, "ns1:IP2LOCATION");
00165 case SOAP_TYPE_PointerTo_ns1__IP2LocationResponse:
00166 return soap_in_PointerTo_ns1__IP2LocationResponse(soap, NULL, NULL, "ns1:IP2LocationResponse");
00167 case SOAP_TYPE_PointerTo_ns1__IP2Location:
00168 return soap_in_PointerTo_ns1__IP2Location(soap, NULL, NULL, "ns1:IP2Location");
00169 case SOAP_TYPE_PointerTons1__IP2LOCATION:
00170 return soap_in_PointerTons1__IP2LOCATION(soap, NULL, NULL, "ns1:IP2LOCATION");
00171 case SOAP_TYPE_string:
00172 { char **s;
00173 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00174 return s ? *s : NULL;
00175 }
00176 default:
00177 { const char *t = soap->type;
00178 if (!*t)
00179 t = soap->tag;
00180 if (!soap_match_tag(soap, t, "xsd:byte"))
00181 { *type = SOAP_TYPE_byte;
00182 return soap_in_byte(soap, NULL, NULL, NULL);
00183 }
00184 if (!soap_match_tag(soap, t, "xsd:int"))
00185 { *type = SOAP_TYPE_int;
00186 return soap_in_int(soap, NULL, NULL, NULL);
00187 }
00188 if (!soap_match_tag(soap, t, "xsd:float"))
00189 { *type = SOAP_TYPE_float;
00190 return soap_in_float(soap, NULL, NULL, NULL);
00191 }
00192 if (!soap_match_tag(soap, t, "ns1:IP2LOCATION"))
00193 { *type = SOAP_TYPE_ns1__IP2LOCATION;
00194 return soap_in_ns1__IP2LOCATION(soap, NULL, NULL, NULL);
00195 }
00196 if (!soap_match_tag(soap, t, "xsd:string"))
00197 { char **s;
00198 *type = SOAP_TYPE_string;
00199 s = soap_in_string(soap, NULL, NULL, NULL);
00200 return s ? *s : NULL;
00201 }
00202 t = soap->tag;
00203 if (!soap_match_tag(soap, t, "ns1:IP2LocationResponse"))
00204 { *type = SOAP_TYPE__ns1__IP2LocationResponse;
00205 return soap_in__ns1__IP2LocationResponse(soap, NULL, NULL, NULL);
00206 }
00207 if (!soap_match_tag(soap, t, "ns1:IP2Location"))
00208 { *type = SOAP_TYPE__ns1__IP2Location;
00209 return soap_in__ns1__IP2Location(soap, NULL, NULL, NULL);
00210 }
00211 if (!soap_match_tag(soap, t, "xsd:QName"))
00212 { char **s;
00213 *type = SOAP_TYPE__QName;
00214 s = soap_in__QName(soap, NULL, NULL, NULL);
00215 return s ? *s : NULL;
00216 }
00217 }
00218 }
00219 soap->error = SOAP_TAG_MISMATCH;
00220 return NULL;
00221 }
00222 #endif
00223
00224 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00225 {
00226 if (!soap_peek_element(soap))
00227 { int t;
00228 if (soap->mustUnderstand && !soap->other)
00229 return soap->error = SOAP_MUSTUNDERSTAND;
00230 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00231 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00232 return soap->error = SOAP_TAG_MISMATCH;
00233 }
00234 if (!*soap->id || !soap_getelement(soap, &t))
00235 { soap->peeked = 0;
00236 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00237 if (soap->fignore)
00238 soap->error = soap->fignore(soap, soap->tag);
00239 else
00240 soap->error = SOAP_OK;
00241 DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00242 if (!soap->error && soap->body)
00243 { soap->level++;
00244 while (!soap_ignore_element(soap))
00245 ;
00246 if (soap->error == SOAP_NO_TAG)
00247 soap->error = soap_element_end_in(soap, NULL);
00248 }
00249 }
00250 }
00251 return soap->error;
00252 }
00253
00254 #ifndef WITH_NOIDREF
00255 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00256 {
00257 int i;
00258 struct soap_plist *pp;
00259 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00260 for (i = 0; i < SOAP_PTRHASH; i++)
00261 for (pp = soap->pht[i]; pp; pp = pp->next)
00262 if (pp->mark1 == 2 || pp->mark2 == 2)
00263 if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00264 return soap->error;
00265 return SOAP_OK;
00266 }
00267 #endif
00268
00269 #ifndef WITH_NOIDREF
00270 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00271 {
00272 switch (type)
00273 {
00274 case SOAP_TYPE_byte:
00275 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00276 case SOAP_TYPE_int:
00277 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00278 case SOAP_TYPE_float:
00279 return soap_out_float(soap, tag, id, (const float *)ptr, "xsd:float");
00280 case SOAP_TYPE__ns1__IP2LocationResponse:
00281 return soap_out__ns1__IP2LocationResponse(soap, "ns1:IP2LocationResponse", id, (const struct _ns1__IP2LocationResponse *)ptr, NULL);
00282 case SOAP_TYPE__ns1__IP2Location:
00283 return soap_out__ns1__IP2Location(soap, "ns1:IP2Location", id, (const struct _ns1__IP2Location *)ptr, NULL);
00284 case SOAP_TYPE_ns1__IP2LOCATION:
00285 return soap_out_ns1__IP2LOCATION(soap, tag, id, (const struct ns1__IP2LOCATION *)ptr, "ns1:IP2LOCATION");
00286 case SOAP_TYPE_PointerTo_ns1__IP2LocationResponse:
00287 return soap_out_PointerTo_ns1__IP2LocationResponse(soap, tag, id, (struct _ns1__IP2LocationResponse *const*)ptr, "ns1:IP2LocationResponse");
00288 case SOAP_TYPE_PointerTo_ns1__IP2Location:
00289 return soap_out_PointerTo_ns1__IP2Location(soap, tag, id, (struct _ns1__IP2Location *const*)ptr, "ns1:IP2Location");
00290 case SOAP_TYPE_PointerTons1__IP2LOCATION:
00291 return soap_out_PointerTons1__IP2LOCATION(soap, tag, id, (struct ns1__IP2LOCATION *const*)ptr, "ns1:IP2LOCATION");
00292 case SOAP_TYPE__QName:
00293 return soap_out_string(soap, "xsd:QName", id, (char*const*)&ptr, NULL);
00294 case SOAP_TYPE_string:
00295 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
00296 }
00297 return SOAP_OK;
00298 }
00299 #endif
00300
00301 #ifndef WITH_NOIDREF
00302 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00303 {
00304 (void)soap; (void)ptr; (void)type;
00305 switch (type)
00306 {
00307 case SOAP_TYPE___ns1__IP2Location:
00308 soap_serialize___ns1__IP2Location(soap, (const struct __ns1__IP2Location *)ptr);
00309 break;
00310 case SOAP_TYPE__ns1__IP2LocationResponse:
00311 soap_serialize__ns1__IP2LocationResponse(soap, (const struct _ns1__IP2LocationResponse *)ptr);
00312 break;
00313 case SOAP_TYPE__ns1__IP2Location:
00314 soap_serialize__ns1__IP2Location(soap, (const struct _ns1__IP2Location *)ptr);
00315 break;
00316 case SOAP_TYPE_ns1__IP2LOCATION:
00317 soap_serialize_ns1__IP2LOCATION(soap, (const struct ns1__IP2LOCATION *)ptr);
00318 break;
00319 case SOAP_TYPE_PointerTo_ns1__IP2LocationResponse:
00320 soap_serialize_PointerTo_ns1__IP2LocationResponse(soap, (struct _ns1__IP2LocationResponse *const*)ptr);
00321 break;
00322 case SOAP_TYPE_PointerTo_ns1__IP2Location:
00323 soap_serialize_PointerTo_ns1__IP2Location(soap, (struct _ns1__IP2Location *const*)ptr);
00324 break;
00325 case SOAP_TYPE_PointerTons1__IP2LOCATION:
00326 soap_serialize_PointerTons1__IP2LOCATION(soap, (struct ns1__IP2LOCATION *const*)ptr);
00327 break;
00328 case SOAP_TYPE__QName:
00329 soap_serialize_string(soap, (char*const*)&ptr);
00330 break;
00331 case SOAP_TYPE_string:
00332 soap_serialize_string(soap, (char*const*)&ptr);
00333 break;
00334 }
00335 }
00336 #endif
00337
00338 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00339 { (void)soap;
00340 #ifdef SOAP_DEFAULT_byte
00341 *a = SOAP_DEFAULT_byte;
00342 #else
00343 *a = (char)0;
00344 #endif
00345 }
00346
00347 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00348 {
00349 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00350 if (soap_out_byte(soap, tag, id, a, type))
00351 return soap->error;
00352 return soap_putindependent(soap);
00353 }
00354
00355 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00356 {
00357 return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00358 }
00359
00360 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00361 {
00362 if ((p = soap_in_byte(soap, tag, p, type)))
00363 if (soap_getindependent(soap))
00364 return NULL;
00365 return p;
00366 }
00367
00368 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00369 {
00370 return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00371 }
00372
00373 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00374 { (void)soap;
00375 #ifdef SOAP_DEFAULT_int
00376 *a = SOAP_DEFAULT_int;
00377 #else
00378 *a = (int)0;
00379 #endif
00380 }
00381
00382 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00383 {
00384 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00385 if (soap_out_int(soap, tag, id, a, type))
00386 return soap->error;
00387 return soap_putindependent(soap);
00388 }
00389
00390 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
00391 {
00392 return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
00393 }
00394
00395 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00396 {
00397 if ((p = soap_in_int(soap, tag, p, type)))
00398 if (soap_getindependent(soap))
00399 return NULL;
00400 return p;
00401 }
00402
00403 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00404 {
00405 return soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00406 }
00407
00408 SOAP_FMAC3 void SOAP_FMAC4 soap_default_float(struct soap *soap, float *a)
00409 { (void)soap;
00410 #ifdef SOAP_DEFAULT_float
00411 *a = SOAP_DEFAULT_float;
00412 #else
00413 *a = (float)0;
00414 #endif
00415 }
00416
00417 SOAP_FMAC3 int SOAP_FMAC4 soap_put_float(struct soap *soap, const float *a, const char *tag, const char *type)
00418 {
00419 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_float);
00420 if (soap_out_float(soap, tag, id, a, type))
00421 return soap->error;
00422 return soap_putindependent(soap);
00423 }
00424
00425 SOAP_FMAC3 int SOAP_FMAC4 soap_out_float(struct soap *soap, const char *tag, int id, const float *a, const char *type)
00426 {
00427 return soap_outfloat(soap, tag, id, a, type, SOAP_TYPE_float);
00428 }
00429
00430 SOAP_FMAC3 float * SOAP_FMAC4 soap_get_float(struct soap *soap, float *p, const char *tag, const char *type)
00431 {
00432 if ((p = soap_in_float(soap, tag, p, type)))
00433 if (soap_getindependent(soap))
00434 return NULL;
00435 return p;
00436 }
00437
00438 SOAP_FMAC3 float * SOAP_FMAC4 soap_in_float(struct soap *soap, const char *tag, float *a, const char *type)
00439 {
00440 return soap_infloat(soap, tag, a, type, SOAP_TYPE_float);
00441 }
00442
00443 #ifndef WITH_NOGLOBAL
00444
00445 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
00446 {
00447 (void)soap; (void)a;
00448 soap_default__QName(soap, &a->faultcode);
00449 soap_default_string(soap, &a->faultstring);
00450 soap_default_string(soap, &a->faultactor);
00451 a->detail = NULL;
00452 a->SOAP_ENV__Code = NULL;
00453 a->SOAP_ENV__Reason = NULL;
00454 soap_default_string(soap, &a->SOAP_ENV__Node);
00455 soap_default_string(soap, &a->SOAP_ENV__Role);
00456 a->SOAP_ENV__Detail = NULL;
00457 }
00458
00459 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
00460 {
00461 (void)soap; (void)a;
00462 soap_serialize__QName(soap, &a->faultcode);
00463 soap_serialize_string(soap, &a->faultstring);
00464 soap_serialize_string(soap, &a->faultactor);
00465 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
00466 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
00467 soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
00468 soap_serialize_string(soap, &a->SOAP_ENV__Node);
00469 soap_serialize_string(soap, &a->SOAP_ENV__Role);
00470 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
00471 }
00472
00473 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)
00474 {
00475 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
00476 if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type))
00477 return soap->error;
00478 return soap_putindependent(soap);
00479 }
00480
00481 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)
00482 {
00483 const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
00484 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
00485 return soap->error;
00486 if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
00487 return soap->error;
00488 if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
00489 return soap->error;
00490 if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
00491 return soap->error;
00492 if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
00493 return soap->error;
00494 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
00495 return soap->error;
00496 if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
00497 return soap->error;
00498 if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
00499 return soap->error;
00500 if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
00501 return soap->error;
00502 if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
00503 return soap->error;
00504 return soap_element_end_out(soap, tag);
00505 }
00506
00507 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)
00508 {
00509 if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
00510 if (soap_getindependent(soap))
00511 return NULL;
00512 return p;
00513 }
00514
00515 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)
00516 {
00517 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;
00518 if (soap_element_begin_in(soap, tag, 0, type))
00519 return NULL;
00520 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);
00521 if (!a)
00522 return NULL;
00523 soap_default_SOAP_ENV__Fault(soap, a);
00524 if (soap->body && !*soap->href)
00525 {
00526 for (;;)
00527 { soap->error = SOAP_TAG_MISMATCH;
00528 if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00529 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
00530 { soap_flag_faultcode--;
00531 continue;
00532 }
00533 if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00534 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
00535 { soap_flag_faultstring--;
00536 continue;
00537 }
00538 if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00539 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
00540 { soap_flag_faultactor--;
00541 continue;
00542 }
00543 if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
00544 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
00545 { soap_flag_detail--;
00546 continue;
00547 }
00548 if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
00549 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
00550 { soap_flag_SOAP_ENV__Code--;
00551 continue;
00552 }
00553 if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
00554 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
00555 { soap_flag_SOAP_ENV__Reason--;
00556 continue;
00557 }
00558 if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00559 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
00560 { soap_flag_SOAP_ENV__Node--;
00561 continue;
00562 }
00563 if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00564 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
00565 { soap_flag_SOAP_ENV__Role--;
00566 continue;
00567 }
00568 if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
00569 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
00570 { soap_flag_SOAP_ENV__Detail--;
00571 continue;
00572 }
00573 if (soap->error == SOAP_TAG_MISMATCH)
00574 soap->error = soap_ignore_element(soap);
00575 if (soap->error == SOAP_NO_TAG)
00576 break;
00577 if (soap->error)
00578 return NULL;
00579 }
00580 if (soap_element_end_in(soap, tag))
00581 return NULL;
00582 }
00583 else
00584 { 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);
00585 if (soap->body && soap_element_end_in(soap, tag))
00586 return NULL;
00587 }
00588 return a;
00589 }
00590
00591 #endif
00592
00593 #ifndef WITH_NOGLOBAL
00594
00595 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
00596 {
00597 (void)soap; (void)a;
00598 soap_default_string(soap, &a->SOAP_ENV__Text);
00599 }
00600
00601 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
00602 {
00603 (void)soap; (void)a;
00604 soap_serialize_string(soap, &a->SOAP_ENV__Text);
00605 }
00606
00607 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)
00608 {
00609 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
00610 if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type))
00611 return soap->error;
00612 return soap_putindependent(soap);
00613 }
00614
00615 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)
00616 {
00617 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
00618 return soap->error;
00619 if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
00620 return soap->error;
00621 return soap_element_end_out(soap, tag);
00622 }
00623
00624 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)
00625 {
00626 if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
00627 if (soap_getindependent(soap))
00628 return NULL;
00629 return p;
00630 }
00631
00632 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)
00633 {
00634 short soap_flag_SOAP_ENV__Text = 1;
00635 if (soap_element_begin_in(soap, tag, 0, type))
00636 return NULL;
00637 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);
00638 if (!a)
00639 return NULL;
00640 soap_default_SOAP_ENV__Reason(soap, a);
00641 if (soap->body && !*soap->href)
00642 {
00643 for (;;)
00644 { soap->error = SOAP_TAG_MISMATCH;
00645 if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00646 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
00647 { soap_flag_SOAP_ENV__Text--;
00648 continue;
00649 }
00650 if (soap->error == SOAP_TAG_MISMATCH)
00651 soap->error = soap_ignore_element(soap);
00652 if (soap->error == SOAP_NO_TAG)
00653 break;
00654 if (soap->error)
00655 return NULL;
00656 }
00657 if (soap_element_end_in(soap, tag))
00658 return NULL;
00659 }
00660 else
00661 { 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);
00662 if (soap->body && soap_element_end_in(soap, tag))
00663 return NULL;
00664 }
00665 return a;
00666 }
00667
00668 #endif
00669
00670 #ifndef WITH_NOGLOBAL
00671
00672 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
00673 {
00674 (void)soap; (void)a;
00675 a->__type = 0;
00676 a->fault = NULL;
00677 a->__any = NULL;
00678 }
00679
00680 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
00681 {
00682 (void)soap; (void)a;
00683 soap_markelement(soap, a->fault, a->__type);
00684 }
00685
00686 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)
00687 {
00688 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
00689 if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type))
00690 return soap->error;
00691 return soap_putindependent(soap);
00692 }
00693
00694 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)
00695 {
00696 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
00697 return soap->error;
00698 if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
00699 return soap->error;
00700 soap_outliteral(soap, "-any", &a->__any, NULL);
00701 return soap_element_end_out(soap, tag);
00702 }
00703
00704 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)
00705 {
00706 if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
00707 if (soap_getindependent(soap))
00708 return NULL;
00709 return p;
00710 }
00711
00712 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)
00713 {
00714 short soap_flag_fault = 1, soap_flag___any = 1;
00715 if (soap_element_begin_in(soap, tag, 0, type))
00716 return NULL;
00717 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);
00718 if (!a)
00719 return NULL;
00720 soap_default_SOAP_ENV__Detail(soap, a);
00721 if (soap->body && !*soap->href)
00722 {
00723 for (;;)
00724 { soap->error = SOAP_TAG_MISMATCH;
00725 if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
00726 if ((a->fault = soap_getelement(soap, &a->__type)))
00727 { soap_flag_fault = 0;
00728 continue;
00729 }
00730 if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00731 if (soap_inliteral(soap, "-any", &a->__any))
00732 { soap_flag___any--;
00733 continue;
00734 }
00735 if (soap->error == SOAP_TAG_MISMATCH)
00736 soap->error = soap_ignore_element(soap);
00737 if (soap->error == SOAP_NO_TAG)
00738 break;
00739 if (soap->error)
00740 return NULL;
00741 }
00742 if (soap_element_end_in(soap, tag))
00743 return NULL;
00744 }
00745 else
00746 { 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);
00747 if (soap->body && soap_element_end_in(soap, tag))
00748 return NULL;
00749 }
00750 return a;
00751 }
00752
00753 #endif
00754
00755 #ifndef WITH_NOGLOBAL
00756
00757 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
00758 {
00759 (void)soap; (void)a;
00760 soap_default__QName(soap, &a->SOAP_ENV__Value);
00761 a->SOAP_ENV__Subcode = NULL;
00762 }
00763
00764 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
00765 {
00766 (void)soap; (void)a;
00767 soap_serialize__QName(soap, &a->SOAP_ENV__Value);
00768 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
00769 }
00770
00771 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)
00772 {
00773 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
00774 if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type))
00775 return soap->error;
00776 return soap_putindependent(soap);
00777 }
00778
00779 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)
00780 {
00781 const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
00782 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
00783 return soap->error;
00784 if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
00785 return soap->error;
00786 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
00787 return soap->error;
00788 return soap_element_end_out(soap, tag);
00789 }
00790
00791 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)
00792 {
00793 if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
00794 if (soap_getindependent(soap))
00795 return NULL;
00796 return p;
00797 }
00798
00799 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)
00800 {
00801 short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1;
00802 if (soap_element_begin_in(soap, tag, 0, type))
00803 return NULL;
00804 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);
00805 if (!a)
00806 return NULL;
00807 soap_default_SOAP_ENV__Code(soap, a);
00808 if (soap->body && !*soap->href)
00809 {
00810 for (;;)
00811 { soap->error = SOAP_TAG_MISMATCH;
00812 if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00813 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
00814 { soap_flag_SOAP_ENV__Value--;
00815 continue;
00816 }
00817 if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
00818 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
00819 { soap_flag_SOAP_ENV__Subcode--;
00820 continue;
00821 }
00822 if (soap->error == SOAP_TAG_MISMATCH)
00823 soap->error = soap_ignore_element(soap);
00824 if (soap->error == SOAP_NO_TAG)
00825 break;
00826 if (soap->error)
00827 return NULL;
00828 }
00829 if (soap_element_end_in(soap, tag))
00830 return NULL;
00831 }
00832 else
00833 { 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);
00834 if (soap->body && soap_element_end_in(soap, tag))
00835 return NULL;
00836 }
00837 return a;
00838 }
00839
00840 #endif
00841
00842 #ifndef WITH_NOGLOBAL
00843
00844 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
00845 {
00846 (void)soap; (void)a;
00847 }
00848
00849 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
00850 {
00851 (void)soap; (void)a;
00852 }
00853
00854 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)
00855 {
00856 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
00857 if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type))
00858 return soap->error;
00859 return soap_putindependent(soap);
00860 }
00861
00862 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)
00863 {
00864 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
00865 return soap->error;
00866 return soap_element_end_out(soap, tag);
00867 }
00868
00869 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)
00870 {
00871 if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
00872 if (soap_getindependent(soap))
00873 return NULL;
00874 return p;
00875 }
00876
00877 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)
00878 {
00879 if (soap_element_begin_in(soap, tag, 0, type))
00880 return NULL;
00881 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);
00882 if (!a)
00883 return NULL;
00884 soap_default_SOAP_ENV__Header(soap, a);
00885 if (soap->body && !*soap->href)
00886 {
00887 for (;;)
00888 { soap->error = SOAP_TAG_MISMATCH;
00889 if (soap->error == SOAP_TAG_MISMATCH)
00890 soap->error = soap_ignore_element(soap);
00891 if (soap->error == SOAP_NO_TAG)
00892 break;
00893 if (soap->error)
00894 return NULL;
00895 }
00896 if (soap_element_end_in(soap, tag))
00897 return NULL;
00898 }
00899 else
00900 { 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);
00901 if (soap->body && soap_element_end_in(soap, tag))
00902 return NULL;
00903 }
00904 return a;
00905 }
00906
00907 #endif
00908
00909 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns1__IP2Location(struct soap *soap, struct __ns1__IP2Location *a)
00910 {
00911 (void)soap; (void)a;
00912 a->ns1__IP2Location = NULL;
00913 }
00914
00915 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns1__IP2Location(struct soap *soap, const struct __ns1__IP2Location *a)
00916 {
00917 (void)soap; (void)a;
00918 soap_serialize_PointerTo_ns1__IP2Location(soap, &a->ns1__IP2Location);
00919 }
00920
00921 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns1__IP2Location(struct soap *soap, const struct __ns1__IP2Location *a, const char *tag, const char *type)
00922 {
00923 register int id = 0;
00924 if (soap_out___ns1__IP2Location(soap, tag, id, a, type))
00925 return soap->error;
00926 return SOAP_OK;
00927 }
00928
00929 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns1__IP2Location(struct soap *soap, const char *tag, int id, const struct __ns1__IP2Location *a, const char *type)
00930 {
00931 if (soap_out_PointerTo_ns1__IP2Location(soap, "ns1:IP2Location", -1, &a->ns1__IP2Location, ""))
00932 return soap->error;
00933 return SOAP_OK;
00934 }
00935
00936 SOAP_FMAC3 struct __ns1__IP2Location * SOAP_FMAC4 soap_get___ns1__IP2Location(struct soap *soap, struct __ns1__IP2Location *p, const char *tag, const char *type)
00937 {
00938 if ((p = soap_in___ns1__IP2Location(soap, tag, p, type)))
00939 if (soap_getindependent(soap))
00940 return NULL;
00941 return p;
00942 }
00943
00944 SOAP_FMAC3 struct __ns1__IP2Location * SOAP_FMAC4 soap_in___ns1__IP2Location(struct soap *soap, const char *tag, struct __ns1__IP2Location *a, const char *type)
00945 {
00946 short soap_flag_ns1__IP2Location = 1;
00947 short soap_flag;
00948 a = (struct __ns1__IP2Location *)soap_id_enter(soap, "", a, SOAP_TYPE___ns1__IP2Location, sizeof(struct __ns1__IP2Location), 0, NULL, NULL, NULL);
00949 if (!a)
00950 return NULL;
00951 soap_default___ns1__IP2Location(soap, a);
00952 for (soap_flag = 0;; soap_flag = 1)
00953 { soap->error = SOAP_TAG_MISMATCH;
00954 if (soap_flag_ns1__IP2Location && soap->error == SOAP_TAG_MISMATCH)
00955 if (soap_in_PointerTo_ns1__IP2Location(soap, "ns1:IP2Location", &a->ns1__IP2Location, ""))
00956 { soap_flag_ns1__IP2Location--;
00957 continue;
00958 }
00959 if (soap->error == SOAP_TAG_MISMATCH)
00960 if (soap_flag)
00961 { soap->error = SOAP_OK;
00962 break;
00963 }
00964 if (soap->error == SOAP_NO_TAG)
00965 break;
00966 if (soap->error)
00967 return NULL;
00968 }
00969 return a;
00970 }
00971
00972 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__IP2LocationResponse(struct soap *soap, struct _ns1__IP2LocationResponse *a)
00973 {
00974 (void)soap; (void)a;
00975 a->IP2LocationResult = NULL;
00976 }
00977
00978 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__IP2LocationResponse(struct soap *soap, const struct _ns1__IP2LocationResponse *a)
00979 {
00980 (void)soap; (void)a;
00981 soap_serialize_PointerTons1__IP2LOCATION(soap, &a->IP2LocationResult);
00982 }
00983
00984 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__IP2LocationResponse(struct soap *soap, const struct _ns1__IP2LocationResponse *a, const char *tag, const char *type)
00985 {
00986 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__IP2LocationResponse);
00987 if (soap_out__ns1__IP2LocationResponse(soap, tag, id, a, type))
00988 return soap->error;
00989 return soap_putindependent(soap);
00990 }
00991
00992 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__IP2LocationResponse(struct soap *soap, const char *tag, int id, const struct _ns1__IP2LocationResponse *a, const char *type)
00993 {
00994 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__IP2LocationResponse), type))
00995 return soap->error;
00996 if (a->IP2LocationResult)
00997 soap_element_result(soap, "ns1:IP2LocationResult");
00998 if (soap_out_PointerTons1__IP2LOCATION(soap, "ns1:IP2LocationResult", -1, &a->IP2LocationResult, ""))
00999 return soap->error;
01000 return soap_element_end_out(soap, tag);
01001 }
01002
01003 SOAP_FMAC3 struct _ns1__IP2LocationResponse * SOAP_FMAC4 soap_get__ns1__IP2LocationResponse(struct soap *soap, struct _ns1__IP2LocationResponse *p, const char *tag, const char *type)
01004 {
01005 if ((p = soap_in__ns1__IP2LocationResponse(soap, tag, p, type)))
01006 if (soap_getindependent(soap))
01007 return NULL;
01008 return p;
01009 }
01010
01011 SOAP_FMAC3 struct _ns1__IP2LocationResponse * SOAP_FMAC4 soap_in__ns1__IP2LocationResponse(struct soap *soap, const char *tag, struct _ns1__IP2LocationResponse *a, const char *type)
01012 {
01013 short soap_flag_IP2LocationResult = 1;
01014 if (soap_element_begin_in(soap, tag, 0, type))
01015 return NULL;
01016 a = (struct _ns1__IP2LocationResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__IP2LocationResponse, sizeof(struct _ns1__IP2LocationResponse), 0, NULL, NULL, NULL);
01017 if (!a)
01018 return NULL;
01019 soap_default__ns1__IP2LocationResponse(soap, a);
01020 if (soap->body && !*soap->href)
01021 {
01022 for (;;)
01023 { soap->error = SOAP_TAG_MISMATCH;
01024 if (soap_flag_IP2LocationResult && soap->error == SOAP_TAG_MISMATCH)
01025 if (soap_in_PointerTons1__IP2LOCATION(soap, "ns1:IP2LocationResult", &a->IP2LocationResult, "ns1:IP2LOCATION"))
01026 { soap_flag_IP2LocationResult--;
01027 continue;
01028 }
01029 soap_check_result(soap, "ns1:IP2LocationResult");
01030 if (soap->error == SOAP_TAG_MISMATCH)
01031 soap->error = soap_ignore_element(soap);
01032 if (soap->error == SOAP_NO_TAG)
01033 break;
01034 if (soap->error)
01035 return NULL;
01036 }
01037 if (soap_element_end_in(soap, tag))
01038 return NULL;
01039 }
01040 else
01041 { a = (struct _ns1__IP2LocationResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__IP2LocationResponse, 0, sizeof(struct _ns1__IP2LocationResponse), 0, NULL);
01042 if (soap->body && soap_element_end_in(soap, tag))
01043 return NULL;
01044 }
01045 return a;
01046 }
01047
01048 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__IP2Location(struct soap *soap, struct _ns1__IP2Location *a)
01049 {
01050 (void)soap; (void)a;
01051 soap_default_string(soap, &a->IP);
01052 soap_default_string(soap, &a->LICENSE);
01053 }
01054
01055 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__IP2Location(struct soap *soap, const struct _ns1__IP2Location *a)
01056 {
01057 (void)soap; (void)a;
01058 soap_serialize_string(soap, &a->IP);
01059 soap_serialize_string(soap, &a->LICENSE);
01060 }
01061
01062 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__IP2Location(struct soap *soap, const struct _ns1__IP2Location *a, const char *tag, const char *type)
01063 {
01064 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__IP2Location);
01065 if (soap_out__ns1__IP2Location(soap, tag, id, a, type))
01066 return soap->error;
01067 return soap_putindependent(soap);
01068 }
01069
01070 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__IP2Location(struct soap *soap, const char *tag, int id, const struct _ns1__IP2Location *a, const char *type)
01071 {
01072 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__IP2Location), type))
01073 return soap->error;
01074 if (soap_out_string(soap, "ns1:IP", -1, &a->IP, ""))
01075 return soap->error;
01076 if (soap_out_string(soap, "ns1:LICENSE", -1, &a->LICENSE, ""))
01077 return soap->error;
01078 return soap_element_end_out(soap, tag);
01079 }
01080
01081 SOAP_FMAC3 struct _ns1__IP2Location * SOAP_FMAC4 soap_get__ns1__IP2Location(struct soap *soap, struct _ns1__IP2Location *p, const char *tag, const char *type)
01082 {
01083 if ((p = soap_in__ns1__IP2Location(soap, tag, p, type)))
01084 if (soap_getindependent(soap))
01085 return NULL;
01086 return p;
01087 }
01088
01089 SOAP_FMAC3 struct _ns1__IP2Location * SOAP_FMAC4 soap_in__ns1__IP2Location(struct soap *soap, const char *tag, struct _ns1__IP2Location *a, const char *type)
01090 {
01091 short soap_flag_IP = 1, soap_flag_LICENSE = 1;
01092 if (soap_element_begin_in(soap, tag, 0, type))
01093 return NULL;
01094 a = (struct _ns1__IP2Location *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__IP2Location, sizeof(struct _ns1__IP2Location), 0, NULL, NULL, NULL);
01095 if (!a)
01096 return NULL;
01097 soap_default__ns1__IP2Location(soap, a);
01098 if (soap->body && !*soap->href)
01099 {
01100 for (;;)
01101 { soap->error = SOAP_TAG_MISMATCH;
01102 if (soap_flag_IP && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01103 if (soap_in_string(soap, "ns1:IP", &a->IP, "xsd:string"))
01104 { soap_flag_IP--;
01105 continue;
01106 }
01107 if (soap_flag_LICENSE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01108 if (soap_in_string(soap, "ns1:LICENSE", &a->LICENSE, "xsd:string"))
01109 { soap_flag_LICENSE--;
01110 continue;
01111 }
01112 if (soap->error == SOAP_TAG_MISMATCH)
01113 soap->error = soap_ignore_element(soap);
01114 if (soap->error == SOAP_NO_TAG)
01115 break;
01116 if (soap->error)
01117 return NULL;
01118 }
01119 if (soap_element_end_in(soap, tag))
01120 return NULL;
01121 }
01122 else
01123 { a = (struct _ns1__IP2Location *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__IP2Location, 0, sizeof(struct _ns1__IP2Location), 0, NULL);
01124 if (soap->body && soap_element_end_in(soap, tag))
01125 return NULL;
01126 }
01127 return a;
01128 }
01129
01130 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__IP2LOCATION(struct soap *soap, struct ns1__IP2LOCATION *a)
01131 {
01132 (void)soap; (void)a;
01133 soap_default_string(soap, &a->COUNTRYCODE);
01134 soap_default_string(soap, &a->COUNTRYNAME);
01135 soap_default_string(soap, &a->REGION);
01136 soap_default_string(soap, &a->CITY);
01137 soap_default_float(soap, &a->LATITUDE);
01138 soap_default_float(soap, &a->LONGITUDE);
01139 soap_default_string(soap, &a->ZIPCODE);
01140 soap_default_string(soap, &a->ISPNAME);
01141 soap_default_string(soap, &a->DOMAINNAME);
01142 soap_default_string(soap, &a->CREDITSAVAILABLE);
01143 soap_default_string(soap, &a->MESSAGE);
01144 }
01145
01146 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__IP2LOCATION(struct soap *soap, const struct ns1__IP2LOCATION *a)
01147 {
01148 (void)soap; (void)a;
01149 soap_serialize_string(soap, &a->COUNTRYCODE);
01150 soap_serialize_string(soap, &a->COUNTRYNAME);
01151 soap_serialize_string(soap, &a->REGION);
01152 soap_serialize_string(soap, &a->CITY);
01153 soap_serialize_string(soap, &a->ZIPCODE);
01154 soap_serialize_string(soap, &a->ISPNAME);
01155 soap_serialize_string(soap, &a->DOMAINNAME);
01156 soap_serialize_string(soap, &a->CREDITSAVAILABLE);
01157 soap_serialize_string(soap, &a->MESSAGE);
01158 }
01159
01160 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__IP2LOCATION(struct soap *soap, const struct ns1__IP2LOCATION *a, const char *tag, const char *type)
01161 {
01162 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__IP2LOCATION);
01163 if (soap_out_ns1__IP2LOCATION(soap, tag, id, a, type))
01164 return soap->error;
01165 return soap_putindependent(soap);
01166 }
01167
01168 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__IP2LOCATION(struct soap *soap, const char *tag, int id, const struct ns1__IP2LOCATION *a, const char *type)
01169 {
01170 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__IP2LOCATION), type))
01171 return soap->error;
01172 if (soap_out_string(soap, "ns1:COUNTRYCODE", -1, &a->COUNTRYCODE, ""))
01173 return soap->error;
01174 if (soap_out_string(soap, "ns1:COUNTRYNAME", -1, &a->COUNTRYNAME, ""))
01175 return soap->error;
01176 if (soap_out_string(soap, "ns1:REGION", -1, &a->REGION, ""))
01177 return soap->error;
01178 if (soap_out_string(soap, "ns1:CITY", -1, &a->CITY, ""))
01179 return soap->error;
01180 if (soap_out_float(soap, "ns1:LATITUDE", -1, &a->LATITUDE, ""))
01181 return soap->error;
01182 if (soap_out_float(soap, "ns1:LONGITUDE", -1, &a->LONGITUDE, ""))
01183 return soap->error;
01184 if (soap_out_string(soap, "ns1:ZIPCODE", -1, &a->ZIPCODE, ""))
01185 return soap->error;
01186 if (soap_out_string(soap, "ns1:ISPNAME", -1, &a->ISPNAME, ""))
01187 return soap->error;
01188 if (soap_out_string(soap, "ns1:DOMAINNAME", -1, &a->DOMAINNAME, ""))
01189 return soap->error;
01190 if (soap_out_string(soap, "ns1:CREDITSAVAILABLE", -1, &a->CREDITSAVAILABLE, ""))
01191 return soap->error;
01192 if (soap_out_string(soap, "ns1:MESSAGE", -1, &a->MESSAGE, ""))
01193 return soap->error;
01194 return soap_element_end_out(soap, tag);
01195 }
01196
01197 SOAP_FMAC3 struct ns1__IP2LOCATION * SOAP_FMAC4 soap_get_ns1__IP2LOCATION(struct soap *soap, struct ns1__IP2LOCATION *p, const char *tag, const char *type)
01198 {
01199 if ((p = soap_in_ns1__IP2LOCATION(soap, tag, p, type)))
01200 if (soap_getindependent(soap))
01201 return NULL;
01202 return p;
01203 }
01204
01205 SOAP_FMAC3 struct ns1__IP2LOCATION * SOAP_FMAC4 soap_in_ns1__IP2LOCATION(struct soap *soap, const char *tag, struct ns1__IP2LOCATION *a, const char *type)
01206 {
01207 short soap_flag_COUNTRYCODE = 1, soap_flag_COUNTRYNAME = 1, soap_flag_REGION = 1, soap_flag_CITY = 1, soap_flag_LATITUDE = 1, soap_flag_LONGITUDE = 1, soap_flag_ZIPCODE = 1, soap_flag_ISPNAME = 1, soap_flag_DOMAINNAME = 1, soap_flag_CREDITSAVAILABLE = 1, soap_flag_MESSAGE = 1;
01208 if (soap_element_begin_in(soap, tag, 0, type))
01209 return NULL;
01210 a = (struct ns1__IP2LOCATION *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__IP2LOCATION, sizeof(struct ns1__IP2LOCATION), 0, NULL, NULL, NULL);
01211 if (!a)
01212 return NULL;
01213 soap_default_ns1__IP2LOCATION(soap, a);
01214 if (soap->body && !*soap->href)
01215 {
01216 for (;;)
01217 { soap->error = SOAP_TAG_MISMATCH;
01218 if (soap_flag_COUNTRYCODE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01219 if (soap_in_string(soap, "ns1:COUNTRYCODE", &a->COUNTRYCODE, "xsd:string"))
01220 { soap_flag_COUNTRYCODE--;
01221 continue;
01222 }
01223 if (soap_flag_COUNTRYNAME && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01224 if (soap_in_string(soap, "ns1:COUNTRYNAME", &a->COUNTRYNAME, "xsd:string"))
01225 { soap_flag_COUNTRYNAME--;
01226 continue;
01227 }
01228 if (soap_flag_REGION && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01229 if (soap_in_string(soap, "ns1:REGION", &a->REGION, "xsd:string"))
01230 { soap_flag_REGION--;
01231 continue;
01232 }
01233 if (soap_flag_CITY && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01234 if (soap_in_string(soap, "ns1:CITY", &a->CITY, "xsd:string"))
01235 { soap_flag_CITY--;
01236 continue;
01237 }
01238 if (soap_flag_LATITUDE && soap->error == SOAP_TAG_MISMATCH)
01239 if (soap_in_float(soap, "ns1:LATITUDE", &a->LATITUDE, "xsd:float"))
01240 { soap_flag_LATITUDE--;
01241 continue;
01242 }
01243 if (soap_flag_LONGITUDE && soap->error == SOAP_TAG_MISMATCH)
01244 if (soap_in_float(soap, "ns1:LONGITUDE", &a->LONGITUDE, "xsd:float"))
01245 { soap_flag_LONGITUDE--;
01246 continue;
01247 }
01248 if (soap_flag_ZIPCODE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01249 if (soap_in_string(soap, "ns1:ZIPCODE", &a->ZIPCODE, "xsd:string"))
01250 { soap_flag_ZIPCODE--;
01251 continue;
01252 }
01253 if (soap_flag_ISPNAME && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01254 if (soap_in_string(soap, "ns1:ISPNAME", &a->ISPNAME, "xsd:string"))
01255 { soap_flag_ISPNAME--;
01256 continue;
01257 }
01258 if (soap_flag_DOMAINNAME && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01259 if (soap_in_string(soap, "ns1:DOMAINNAME", &a->DOMAINNAME, "xsd:string"))
01260 { soap_flag_DOMAINNAME--;
01261 continue;
01262 }
01263 if (soap_flag_CREDITSAVAILABLE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01264 if (soap_in_string(soap, "ns1:CREDITSAVAILABLE", &a->CREDITSAVAILABLE, "xsd:string"))
01265 { soap_flag_CREDITSAVAILABLE--;
01266 continue;
01267 }
01268 if (soap_flag_MESSAGE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01269 if (soap_in_string(soap, "ns1:MESSAGE", &a->MESSAGE, "xsd:string"))
01270 { soap_flag_MESSAGE--;
01271 continue;
01272 }
01273 if (soap->error == SOAP_TAG_MISMATCH)
01274 soap->error = soap_ignore_element(soap);
01275 if (soap->error == SOAP_NO_TAG)
01276 break;
01277 if (soap->error)
01278 return NULL;
01279 }
01280 if (soap_element_end_in(soap, tag))
01281 return NULL;
01282 }
01283 else
01284 { a = (struct ns1__IP2LOCATION *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__IP2LOCATION, 0, sizeof(struct ns1__IP2LOCATION), 0, NULL);
01285 if (soap->body && soap_element_end_in(soap, tag))
01286 return NULL;
01287 }
01288 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_LATITUDE > 0 || soap_flag_LONGITUDE > 0))
01289 { soap->error = SOAP_OCCURS;
01290 return NULL;
01291 }
01292 return a;
01293 }
01294
01295 #ifndef WITH_NOGLOBAL
01296
01297 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
01298 {
01299 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
01300 soap_serialize_SOAP_ENV__Reason(soap, *a);
01301 }
01302
01303 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)
01304 {
01305 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
01306 if (soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, a, type))
01307 return soap->error;
01308 return soap_putindependent(soap);
01309 }
01310
01311 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)
01312 {
01313 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
01314 if (id < 0)
01315 return soap->error;
01316 return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
01317 }
01318
01319 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)
01320 {
01321 if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
01322 if (soap_getindependent(soap))
01323 return NULL;
01324 return p;
01325 }
01326
01327 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)
01328 {
01329 if (soap_element_begin_in(soap, tag, 1, NULL))
01330 return NULL;
01331 if (!a)
01332 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
01333 return NULL;
01334 *a = NULL;
01335 if (!soap->null && *soap->href != '#')
01336 { soap_revert(soap);
01337 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
01338 return NULL;
01339 }
01340 else
01341 { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
01342 if (soap->body && soap_element_end_in(soap, tag))
01343 return NULL;
01344 }
01345 return a;
01346 }
01347
01348 #endif
01349
01350 #ifndef WITH_NOGLOBAL
01351
01352 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
01353 {
01354 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
01355 soap_serialize_SOAP_ENV__Detail(soap, *a);
01356 }
01357
01358 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)
01359 {
01360 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
01361 if (soap_out_PointerToSOAP_ENV__Detail(soap, tag, id, a, type))
01362 return soap->error;
01363 return soap_putindependent(soap);
01364 }
01365
01366 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)
01367 {
01368 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
01369 if (id < 0)
01370 return soap->error;
01371 return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
01372 }
01373
01374 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)
01375 {
01376 if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
01377 if (soap_getindependent(soap))
01378 return NULL;
01379 return p;
01380 }
01381
01382 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)
01383 {
01384 if (soap_element_begin_in(soap, tag, 1, NULL))
01385 return NULL;
01386 if (!a)
01387 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
01388 return NULL;
01389 *a = NULL;
01390 if (!soap->null && *soap->href != '#')
01391 { soap_revert(soap);
01392 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
01393 return NULL;
01394 }
01395 else
01396 { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
01397 if (soap->body && soap_element_end_in(soap, tag))
01398 return NULL;
01399 }
01400 return a;
01401 }
01402
01403 #endif
01404
01405 #ifndef WITH_NOGLOBAL
01406
01407 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
01408 {
01409 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
01410 soap_serialize_SOAP_ENV__Code(soap, *a);
01411 }
01412
01413 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)
01414 {
01415 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
01416 if (soap_out_PointerToSOAP_ENV__Code(soap, tag, id, a, type))
01417 return soap->error;
01418 return soap_putindependent(soap);
01419 }
01420
01421 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)
01422 {
01423 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
01424 if (id < 0)
01425 return soap->error;
01426 return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
01427 }
01428
01429 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)
01430 {
01431 if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
01432 if (soap_getindependent(soap))
01433 return NULL;
01434 return p;
01435 }
01436
01437 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)
01438 {
01439 if (soap_element_begin_in(soap, tag, 1, NULL))
01440 return NULL;
01441 if (!a)
01442 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
01443 return NULL;
01444 *a = NULL;
01445 if (!soap->null && *soap->href != '#')
01446 { soap_revert(soap);
01447 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
01448 return NULL;
01449 }
01450 else
01451 { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
01452 if (soap->body && soap_element_end_in(soap, tag))
01453 return NULL;
01454 }
01455 return a;
01456 }
01457
01458 #endif
01459
01460 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__IP2LocationResponse(struct soap *soap, struct _ns1__IP2LocationResponse *const*a)
01461 {
01462 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__IP2LocationResponse))
01463 soap_serialize__ns1__IP2LocationResponse(soap, *a);
01464 }
01465
01466 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__IP2LocationResponse(struct soap *soap, struct _ns1__IP2LocationResponse *const*a, const char *tag, const char *type)
01467 {
01468 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__IP2LocationResponse);
01469 if (soap_out_PointerTo_ns1__IP2LocationResponse(soap, tag, id, a, type))
01470 return soap->error;
01471 return soap_putindependent(soap);
01472 }
01473
01474 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__IP2LocationResponse(struct soap *soap, const char *tag, int id, struct _ns1__IP2LocationResponse *const*a, const char *type)
01475 {
01476 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__IP2LocationResponse);
01477 if (id < 0)
01478 return soap->error;
01479 return soap_out__ns1__IP2LocationResponse(soap, tag, id, *a, type);
01480 }
01481
01482 SOAP_FMAC3 struct _ns1__IP2LocationResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__IP2LocationResponse(struct soap *soap, struct _ns1__IP2LocationResponse **p, const char *tag, const char *type)
01483 {
01484 if ((p = soap_in_PointerTo_ns1__IP2LocationResponse(soap, tag, p, type)))
01485 if (soap_getindependent(soap))
01486 return NULL;
01487 return p;
01488 }
01489
01490 SOAP_FMAC3 struct _ns1__IP2LocationResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__IP2LocationResponse(struct soap *soap, const char *tag, struct _ns1__IP2LocationResponse **a, const char *type)
01491 {
01492 if (soap_element_begin_in(soap, tag, 1, NULL))
01493 return NULL;
01494 if (!a)
01495 if (!(a = (struct _ns1__IP2LocationResponse **)soap_malloc(soap, sizeof(struct _ns1__IP2LocationResponse *))))
01496 return NULL;
01497 *a = NULL;
01498 if (!soap->null && *soap->href != '#')
01499 { soap_revert(soap);
01500 if (!(*a = soap_in__ns1__IP2LocationResponse(soap, tag, *a, type)))
01501 return NULL;
01502 }
01503 else
01504 { a = (struct _ns1__IP2LocationResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__IP2LocationResponse, sizeof(struct _ns1__IP2LocationResponse), 0);
01505 if (soap->body && soap_element_end_in(soap, tag))
01506 return NULL;
01507 }
01508 return a;
01509 }
01510
01511 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__IP2Location(struct soap *soap, struct _ns1__IP2Location *const*a)
01512 {
01513 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__IP2Location))
01514 soap_serialize__ns1__IP2Location(soap, *a);
01515 }
01516
01517 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__IP2Location(struct soap *soap, struct _ns1__IP2Location *const*a, const char *tag, const char *type)
01518 {
01519 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__IP2Location);
01520 if (soap_out_PointerTo_ns1__IP2Location(soap, tag, id, a, type))
01521 return soap->error;
01522 return soap_putindependent(soap);
01523 }
01524
01525 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__IP2Location(struct soap *soap, const char *tag, int id, struct _ns1__IP2Location *const*a, const char *type)
01526 {
01527 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__IP2Location);
01528 if (id < 0)
01529 return soap->error;
01530 return soap_out__ns1__IP2Location(soap, tag, id, *a, type);
01531 }
01532
01533 SOAP_FMAC3 struct _ns1__IP2Location ** SOAP_FMAC4 soap_get_PointerTo_ns1__IP2Location(struct soap *soap, struct _ns1__IP2Location **p, const char *tag, const char *type)
01534 {
01535 if ((p = soap_in_PointerTo_ns1__IP2Location(soap, tag, p, type)))
01536 if (soap_getindependent(soap))
01537 return NULL;
01538 return p;
01539 }
01540
01541 SOAP_FMAC3 struct _ns1__IP2Location ** SOAP_FMAC4 soap_in_PointerTo_ns1__IP2Location(struct soap *soap, const char *tag, struct _ns1__IP2Location **a, const char *type)
01542 {
01543 if (soap_element_begin_in(soap, tag, 1, NULL))
01544 return NULL;
01545 if (!a)
01546 if (!(a = (struct _ns1__IP2Location **)soap_malloc(soap, sizeof(struct _ns1__IP2Location *))))
01547 return NULL;
01548 *a = NULL;
01549 if (!soap->null && *soap->href != '#')
01550 { soap_revert(soap);
01551 if (!(*a = soap_in__ns1__IP2Location(soap, tag, *a, type)))
01552 return NULL;
01553 }
01554 else
01555 { a = (struct _ns1__IP2Location **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__IP2Location, sizeof(struct _ns1__IP2Location), 0);
01556 if (soap->body && soap_element_end_in(soap, tag))
01557 return NULL;
01558 }
01559 return a;
01560 }
01561
01562 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__IP2LOCATION(struct soap *soap, struct ns1__IP2LOCATION *const*a)
01563 {
01564 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__IP2LOCATION))
01565 soap_serialize_ns1__IP2LOCATION(soap, *a);
01566 }
01567
01568 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__IP2LOCATION(struct soap *soap, struct ns1__IP2LOCATION *const*a, const char *tag, const char *type)
01569 {
01570 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__IP2LOCATION);
01571 if (soap_out_PointerTons1__IP2LOCATION(soap, tag, id, a, type))
01572 return soap->error;
01573 return soap_putindependent(soap);
01574 }
01575
01576 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__IP2LOCATION(struct soap *soap, const char *tag, int id, struct ns1__IP2LOCATION *const*a, const char *type)
01577 {
01578 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__IP2LOCATION);
01579 if (id < 0)
01580 return soap->error;
01581 return soap_out_ns1__IP2LOCATION(soap, tag, id, *a, type);
01582 }
01583
01584 SOAP_FMAC3 struct ns1__IP2LOCATION ** SOAP_FMAC4 soap_get_PointerTons1__IP2LOCATION(struct soap *soap, struct ns1__IP2LOCATION **p, const char *tag, const char *type)
01585 {
01586 if ((p = soap_in_PointerTons1__IP2LOCATION(soap, tag, p, type)))
01587 if (soap_getindependent(soap))
01588 return NULL;
01589 return p;
01590 }
01591
01592 SOAP_FMAC3 struct ns1__IP2LOCATION ** SOAP_FMAC4 soap_in_PointerTons1__IP2LOCATION(struct soap *soap, const char *tag, struct ns1__IP2LOCATION **a, const char *type)
01593 {
01594 if (soap_element_begin_in(soap, tag, 1, NULL))
01595 return NULL;
01596 if (!a)
01597 if (!(a = (struct ns1__IP2LOCATION **)soap_malloc(soap, sizeof(struct ns1__IP2LOCATION *))))
01598 return NULL;
01599 *a = NULL;
01600 if (!soap->null && *soap->href != '#')
01601 { soap_revert(soap);
01602 if (!(*a = soap_in_ns1__IP2LOCATION(soap, tag, *a, type)))
01603 return NULL;
01604 }
01605 else
01606 { a = (struct ns1__IP2LOCATION **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__IP2LOCATION, sizeof(struct ns1__IP2LOCATION), 0);
01607 if (soap->body && soap_element_end_in(soap, tag))
01608 return NULL;
01609 }
01610 return a;
01611 }
01612
01613 SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap *soap, char **a)
01614 { soap_default_string(soap, a);
01615 }
01616
01617 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a)
01618 { soap_serialize_string(soap, a);
01619 }
01620
01621 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
01622 {
01623 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
01624 if (soap_out__QName(soap, tag, id, a, type))
01625 return soap->error;
01626 return soap_putindependent(soap);
01627 }
01628
01629 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01630 {
01631 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
01632 }
01633
01634 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
01635 {
01636 if ((p = soap_in__QName(soap, tag, p, type)))
01637 if (soap_getindependent(soap))
01638 return NULL;
01639 return p;
01640 }
01641
01642 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
01643 {
01644 return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1);
01645 }
01646
01647 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
01648 { (void)soap;
01649 #ifdef SOAP_DEFAULT_string
01650 *a = SOAP_DEFAULT_string;
01651 #else
01652 *a = (char *)0;
01653 #endif
01654 }
01655
01656 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
01657 {
01658 soap_reference(soap, *a, SOAP_TYPE_string);
01659 }
01660
01661 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
01662 {
01663 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
01664 if (soap_out_string(soap, tag, id, a, type))
01665 return soap->error;
01666 return soap_putindependent(soap);
01667 }
01668
01669 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
01670 {
01671 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
01672 }
01673
01674 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
01675 {
01676 if ((p = soap_in_string(soap, tag, p, type)))
01677 if (soap_getindependent(soap))
01678 return NULL;
01679 return p;
01680 }
01681
01682 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
01683 {
01684 return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1);
01685 }
01686
01687 #ifdef __cplusplus
01688 }
01689 #endif
01690
01691