00001
00002
00003
00004
00005
00006
00007
00008 #include "sdssImgCutoutH.h"
00009
00010 #ifdef __cplusplus
00011 extern "C" {
00012 #endif
00013
00014 SOAP_SOURCE_STAMP("@(#) sdssImgCutoutC.c ver 2.7.9l 2008-01-25 19:19:35 GMT")
00015
00016
00017 #ifndef WITH_NOGLOBAL
00018
00019 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
00020 {
00021 if (soap->header)
00022 soap_serialize_SOAP_ENV__Header(soap, soap->header);
00023 }
00024
00025 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
00026 {
00027 if (soap->header)
00028 { soap->part = SOAP_IN_HEADER;
00029 if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
00030 return soap->error;
00031 soap->part = SOAP_END_HEADER;
00032 }
00033 return SOAP_OK;
00034 }
00035
00036 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
00037 {
00038 soap->part = SOAP_IN_HEADER;
00039 soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
00040 soap->part = SOAP_END_HEADER;
00041 return soap->header == NULL;
00042 }
00043
00044 SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
00045 {
00046 if (!soap->header)
00047 { soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
00048 soap_default_SOAP_ENV__Header(soap, soap->header);
00049 }
00050 }
00051
00052 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
00053 {
00054 if (!soap->fault)
00055 { soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault));
00056 soap_default_SOAP_ENV__Fault(soap, soap->fault);
00057 }
00058 if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
00059 { soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00060 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
00061 }
00062 if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
00063 { soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason));
00064 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
00065 }
00066 }
00067
00068 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
00069 {
00070 if (soap->fault)
00071 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
00072 }
00073
00074 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
00075 {
00076 if (soap->fault)
00077 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
00078 return SOAP_OK;
00079 }
00080
00081 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
00082 {
00083 return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
00084 }
00085
00086 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
00087 {
00088 soap_fault(soap);
00089 if (soap->version == 2)
00090 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
00091 return (const char**)&soap->fault->faultcode;
00092 }
00093
00094 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
00095 {
00096 soap_fault(soap);
00097 if (soap->version == 2)
00098 { if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
00099 { soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00100 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
00101 }
00102 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
00103 }
00104 return (const char**)&soap->fault->faultcode;
00105 }
00106
00107 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
00108 {
00109 soap_fault(soap);
00110 if (soap->version == 2)
00111 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
00112 return (const char**)&soap->fault->faultstring;
00113 }
00114
00115 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
00116 {
00117 soap_fault(soap);
00118 if (soap->version == 1)
00119 { if (!soap->fault->detail)
00120 { soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00121 soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
00122 }
00123 return (const char**)&soap->fault->detail->__any;
00124 }
00125 if (!soap->fault->SOAP_ENV__Detail)
00126 { soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00127 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
00128 }
00129 return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
00130 }
00131
00132 #endif
00133
00134 #ifndef WITH_NOIDREF
00135 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
00136 {
00137 int t;
00138 for (;;)
00139 if (!soap_getelement(soap, &t))
00140 if (soap->error || soap_ignore_element(soap))
00141 break;
00142 if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
00143 soap->error = SOAP_OK;
00144 return soap->error;
00145 }
00146 #endif
00147
00148 #ifndef WITH_NOIDREF
00149 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
00150 {
00151 if (soap_peek_element(soap))
00152 return NULL;
00153 if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
00154 *type = soap_lookup_type(soap, soap->href);
00155 switch (*type)
00156 {
00157 case SOAP_TYPE_byte:
00158 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
00159 case SOAP_TYPE_int:
00160 return soap_in_int(soap, NULL, NULL, "xsd:int");
00161 case SOAP_TYPE_double:
00162 return soap_in_double(soap, NULL, NULL, "xsd:double");
00163 case SOAP_TYPE_unsignedByte:
00164 return soap_in_unsignedByte(soap, NULL, NULL, "xsd:unsignedByte");
00165 case SOAP_TYPE_unsignedInt:
00166 return soap_in_unsignedInt(soap, NULL, NULL, "xsd:unsignedInt");
00167 case SOAP_TYPE_ns1__ArrayOfString:
00168 return soap_in_ns1__ArrayOfString(soap, NULL, NULL, "ns1:ArrayOfString");
00169 case SOAP_TYPE_xsd__base64Binary:
00170 return soap_in_xsd__base64Binary(soap, NULL, NULL, "xsd:base64Binary");
00171 case SOAP_TYPE_PointerTo_ns1__DimeJpegResponse:
00172 return soap_in_PointerTo_ns1__DimeJpegResponse(soap, NULL, NULL, "ns1:DimeJpegResponse");
00173 case SOAP_TYPE_PointerTo_ns1__DimeJpeg:
00174 return soap_in_PointerTo_ns1__DimeJpeg(soap, NULL, NULL, "ns1:DimeJpeg");
00175 case SOAP_TYPE_PointerTo_ns1__GetJpegQueryResponse:
00176 return soap_in_PointerTo_ns1__GetJpegQueryResponse(soap, NULL, NULL, "ns1:GetJpegQueryResponse");
00177 case SOAP_TYPE_PointerTo_ns1__GetJpegQuery:
00178 return soap_in_PointerTo_ns1__GetJpegQuery(soap, NULL, NULL, "ns1:GetJpegQuery");
00179 case SOAP_TYPE_PointerTo_ns1__GetJpegResponse:
00180 return soap_in_PointerTo_ns1__GetJpegResponse(soap, NULL, NULL, "ns1:GetJpegResponse");
00181 case SOAP_TYPE_PointerTo_ns1__GetJpeg:
00182 return soap_in_PointerTo_ns1__GetJpeg(soap, NULL, NULL, "ns1:GetJpeg");
00183 case SOAP_TYPE_PointerTo_ns1__RevisionsResponse:
00184 return soap_in_PointerTo_ns1__RevisionsResponse(soap, NULL, NULL, "ns1:RevisionsResponse");
00185 case SOAP_TYPE_PointerTo_ns1__Revisions:
00186 return soap_in_PointerTo_ns1__Revisions(soap, NULL, NULL, "ns1:Revisions");
00187 case SOAP_TYPE_PointerToxsd__base64Binary:
00188 return soap_in_PointerToxsd__base64Binary(soap, NULL, NULL, "xsd:base64Binary");
00189 case SOAP_TYPE_PointerTons1__ArrayOfString:
00190 return soap_in_PointerTons1__ArrayOfString(soap, NULL, NULL, "ns1:ArrayOfString");
00191 case SOAP_TYPE_PointerTostring:
00192 return soap_in_PointerTostring(soap, NULL, NULL, "xsd:string");
00193 case SOAP_TYPE_PointerTounsignedByte:
00194 return soap_in_PointerTounsignedByte(soap, NULL, NULL, "xsd:unsignedByte");
00195 case SOAP_TYPE_string:
00196 { char **s;
00197 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00198 return s ? *s : NULL;
00199 }
00200 default:
00201 { const char *t = soap->type;
00202 if (!*t)
00203 t = soap->tag;
00204 if (!soap_match_tag(soap, t, "xsd:byte"))
00205 { *type = SOAP_TYPE_byte;
00206 return soap_in_byte(soap, NULL, NULL, NULL);
00207 }
00208 if (!soap_match_tag(soap, t, "xsd:int"))
00209 { *type = SOAP_TYPE_int;
00210 return soap_in_int(soap, NULL, NULL, NULL);
00211 }
00212 if (!soap_match_tag(soap, t, "xsd:double"))
00213 { *type = SOAP_TYPE_double;
00214 return soap_in_double(soap, NULL, NULL, NULL);
00215 }
00216 if (!soap_match_tag(soap, t, "xsd:unsignedByte"))
00217 { *type = SOAP_TYPE_unsignedByte;
00218 return soap_in_unsignedByte(soap, NULL, NULL, NULL);
00219 }
00220 if (!soap_match_tag(soap, t, "xsd:unsignedInt"))
00221 { *type = SOAP_TYPE_unsignedInt;
00222 return soap_in_unsignedInt(soap, NULL, NULL, NULL);
00223 }
00224 if (!soap_match_tag(soap, t, "ns1:ArrayOfString"))
00225 { *type = SOAP_TYPE_ns1__ArrayOfString;
00226 return soap_in_ns1__ArrayOfString(soap, NULL, NULL, NULL);
00227 }
00228 if (!soap_match_tag(soap, t, "xsd:base64Binary"))
00229 { *type = SOAP_TYPE_xsd__base64Binary;
00230 return soap_in_xsd__base64Binary(soap, NULL, NULL, NULL);
00231 }
00232 if (!soap_match_tag(soap, t, "xsd:string"))
00233 { char **s;
00234 *type = SOAP_TYPE_string;
00235 s = soap_in_string(soap, NULL, NULL, NULL);
00236 return s ? *s : NULL;
00237 }
00238 t = soap->tag;
00239 if (!soap_match_tag(soap, t, "ns1:DimeJpegResponse"))
00240 { *type = SOAP_TYPE__ns1__DimeJpegResponse;
00241 return soap_in__ns1__DimeJpegResponse(soap, NULL, NULL, NULL);
00242 }
00243 if (!soap_match_tag(soap, t, "ns1:DimeJpeg"))
00244 { *type = SOAP_TYPE__ns1__DimeJpeg;
00245 return soap_in__ns1__DimeJpeg(soap, NULL, NULL, NULL);
00246 }
00247 if (!soap_match_tag(soap, t, "ns1:GetJpegQueryResponse"))
00248 { *type = SOAP_TYPE__ns1__GetJpegQueryResponse;
00249 return soap_in__ns1__GetJpegQueryResponse(soap, NULL, NULL, NULL);
00250 }
00251 if (!soap_match_tag(soap, t, "ns1:GetJpegQuery"))
00252 { *type = SOAP_TYPE__ns1__GetJpegQuery;
00253 return soap_in__ns1__GetJpegQuery(soap, NULL, NULL, NULL);
00254 }
00255 if (!soap_match_tag(soap, t, "ns1:GetJpegResponse"))
00256 { *type = SOAP_TYPE__ns1__GetJpegResponse;
00257 return soap_in__ns1__GetJpegResponse(soap, NULL, NULL, NULL);
00258 }
00259 if (!soap_match_tag(soap, t, "ns1:GetJpeg"))
00260 { *type = SOAP_TYPE__ns1__GetJpeg;
00261 return soap_in__ns1__GetJpeg(soap, NULL, NULL, NULL);
00262 }
00263 if (!soap_match_tag(soap, t, "ns1:RevisionsResponse"))
00264 { *type = SOAP_TYPE__ns1__RevisionsResponse;
00265 return soap_in__ns1__RevisionsResponse(soap, NULL, NULL, NULL);
00266 }
00267 if (!soap_match_tag(soap, t, "ns1:Revisions"))
00268 { *type = SOAP_TYPE__ns1__Revisions;
00269 return soap_in__ns1__Revisions(soap, NULL, NULL, NULL);
00270 }
00271 if (!soap_match_tag(soap, t, "xsd:QName"))
00272 { char **s;
00273 *type = SOAP_TYPE__QName;
00274 s = soap_in__QName(soap, NULL, NULL, NULL);
00275 return s ? *s : NULL;
00276 }
00277 }
00278 }
00279 soap->error = SOAP_TAG_MISMATCH;
00280 return NULL;
00281 }
00282 #endif
00283
00284 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00285 {
00286 if (!soap_peek_element(soap))
00287 { int t;
00288 if (soap->mustUnderstand && !soap->other)
00289 return soap->error = SOAP_MUSTUNDERSTAND;
00290 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00291 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00292 return soap->error = SOAP_TAG_MISMATCH;
00293 }
00294 if (!*soap->id || !soap_getelement(soap, &t))
00295 { soap->peeked = 0;
00296 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00297 if (soap->fignore)
00298 soap->error = soap->fignore(soap, soap->tag);
00299 else
00300 soap->error = SOAP_OK;
00301 DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00302 if (!soap->error && soap->body)
00303 { soap->level++;
00304 while (!soap_ignore_element(soap))
00305 ;
00306 if (soap->error == SOAP_NO_TAG)
00307 soap->error = soap_element_end_in(soap, NULL);
00308 }
00309 }
00310 }
00311 return soap->error;
00312 }
00313
00314 #ifndef WITH_NOIDREF
00315 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00316 {
00317 int i;
00318 struct soap_plist *pp;
00319 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00320 for (i = 0; i < SOAP_PTRHASH; i++)
00321 for (pp = soap->pht[i]; pp; pp = pp->next)
00322 if (pp->mark1 == 2 || pp->mark2 == 2)
00323 if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00324 return soap->error;
00325 return SOAP_OK;
00326 }
00327 #endif
00328
00329 #ifndef WITH_NOIDREF
00330 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00331 {
00332 switch (type)
00333 {
00334 case SOAP_TYPE_byte:
00335 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00336 case SOAP_TYPE_int:
00337 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00338 case SOAP_TYPE_double:
00339 return soap_out_double(soap, tag, id, (const double *)ptr, "xsd:double");
00340 case SOAP_TYPE_unsignedByte:
00341 return soap_out_unsignedByte(soap, tag, id, (const unsigned char *)ptr, "xsd:unsignedByte");
00342 case SOAP_TYPE_unsignedInt:
00343 return soap_out_unsignedInt(soap, tag, id, (const unsigned int *)ptr, "xsd:unsignedInt");
00344 case SOAP_TYPE__ns1__DimeJpegResponse:
00345 return soap_out__ns1__DimeJpegResponse(soap, "ns1:DimeJpegResponse", id, (const struct _ns1__DimeJpegResponse *)ptr, NULL);
00346 case SOAP_TYPE__ns1__DimeJpeg:
00347 return soap_out__ns1__DimeJpeg(soap, "ns1:DimeJpeg", id, (const struct _ns1__DimeJpeg *)ptr, NULL);
00348 case SOAP_TYPE__ns1__GetJpegQueryResponse:
00349 return soap_out__ns1__GetJpegQueryResponse(soap, "ns1:GetJpegQueryResponse", id, (const struct _ns1__GetJpegQueryResponse *)ptr, NULL);
00350 case SOAP_TYPE__ns1__GetJpegQuery:
00351 return soap_out__ns1__GetJpegQuery(soap, "ns1:GetJpegQuery", id, (const struct _ns1__GetJpegQuery *)ptr, NULL);
00352 case SOAP_TYPE__ns1__GetJpegResponse:
00353 return soap_out__ns1__GetJpegResponse(soap, "ns1:GetJpegResponse", id, (const struct _ns1__GetJpegResponse *)ptr, NULL);
00354 case SOAP_TYPE__ns1__GetJpeg:
00355 return soap_out__ns1__GetJpeg(soap, "ns1:GetJpeg", id, (const struct _ns1__GetJpeg *)ptr, NULL);
00356 case SOAP_TYPE__ns1__RevisionsResponse:
00357 return soap_out__ns1__RevisionsResponse(soap, "ns1:RevisionsResponse", id, (const struct _ns1__RevisionsResponse *)ptr, NULL);
00358 case SOAP_TYPE__ns1__Revisions:
00359 return soap_out__ns1__Revisions(soap, "ns1:Revisions", id, (const struct _ns1__Revisions *)ptr, NULL);
00360 case SOAP_TYPE_ns1__ArrayOfString:
00361 return soap_out_ns1__ArrayOfString(soap, tag, id, (const struct ns1__ArrayOfString *)ptr, "ns1:ArrayOfString");
00362 case SOAP_TYPE_xsd__base64Binary:
00363 return soap_out_xsd__base64Binary(soap, tag, id, (const struct xsd__base64Binary *)ptr, "xsd:base64Binary");
00364 case SOAP_TYPE_PointerTo_ns1__DimeJpegResponse:
00365 return soap_out_PointerTo_ns1__DimeJpegResponse(soap, tag, id, (struct _ns1__DimeJpegResponse *const*)ptr, "ns1:DimeJpegResponse");
00366 case SOAP_TYPE_PointerTo_ns1__DimeJpeg:
00367 return soap_out_PointerTo_ns1__DimeJpeg(soap, tag, id, (struct _ns1__DimeJpeg *const*)ptr, "ns1:DimeJpeg");
00368 case SOAP_TYPE_PointerTo_ns1__GetJpegQueryResponse:
00369 return soap_out_PointerTo_ns1__GetJpegQueryResponse(soap, tag, id, (struct _ns1__GetJpegQueryResponse *const*)ptr, "ns1:GetJpegQueryResponse");
00370 case SOAP_TYPE_PointerTo_ns1__GetJpegQuery:
00371 return soap_out_PointerTo_ns1__GetJpegQuery(soap, tag, id, (struct _ns1__GetJpegQuery *const*)ptr, "ns1:GetJpegQuery");
00372 case SOAP_TYPE_PointerTo_ns1__GetJpegResponse:
00373 return soap_out_PointerTo_ns1__GetJpegResponse(soap, tag, id, (struct _ns1__GetJpegResponse *const*)ptr, "ns1:GetJpegResponse");
00374 case SOAP_TYPE_PointerTo_ns1__GetJpeg:
00375 return soap_out_PointerTo_ns1__GetJpeg(soap, tag, id, (struct _ns1__GetJpeg *const*)ptr, "ns1:GetJpeg");
00376 case SOAP_TYPE_PointerTo_ns1__RevisionsResponse:
00377 return soap_out_PointerTo_ns1__RevisionsResponse(soap, tag, id, (struct _ns1__RevisionsResponse *const*)ptr, "ns1:RevisionsResponse");
00378 case SOAP_TYPE_PointerTo_ns1__Revisions:
00379 return soap_out_PointerTo_ns1__Revisions(soap, tag, id, (struct _ns1__Revisions *const*)ptr, "ns1:Revisions");
00380 case SOAP_TYPE_PointerToxsd__base64Binary:
00381 return soap_out_PointerToxsd__base64Binary(soap, tag, id, (struct xsd__base64Binary *const*)ptr, "xsd:base64Binary");
00382 case SOAP_TYPE_PointerTons1__ArrayOfString:
00383 return soap_out_PointerTons1__ArrayOfString(soap, tag, id, (struct ns1__ArrayOfString *const*)ptr, "ns1:ArrayOfString");
00384 case SOAP_TYPE_PointerTostring:
00385 return soap_out_PointerTostring(soap, tag, id, (char **const*)ptr, "xsd:string");
00386 case SOAP_TYPE_PointerTounsignedByte:
00387 return soap_out_PointerTounsignedByte(soap, tag, id, (unsigned char *const*)ptr, "xsd:unsignedByte");
00388 case SOAP_TYPE__QName:
00389 return soap_out_string(soap, "xsd:QName", id, (char*const*)&ptr, NULL);
00390 case SOAP_TYPE_string:
00391 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
00392 }
00393 return SOAP_OK;
00394 }
00395 #endif
00396
00397 #ifndef WITH_NOIDREF
00398 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00399 {
00400 (void)soap; (void)ptr; (void)type;
00401 switch (type)
00402 {
00403 case SOAP_TYPE___ns3__DimeJpeg:
00404 soap_serialize___ns3__DimeJpeg(soap, (const struct __ns3__DimeJpeg *)ptr);
00405 break;
00406 case SOAP_TYPE___ns3__GetJpegQuery:
00407 soap_serialize___ns3__GetJpegQuery(soap, (const struct __ns3__GetJpegQuery *)ptr);
00408 break;
00409 case SOAP_TYPE___ns3__GetJpeg:
00410 soap_serialize___ns3__GetJpeg(soap, (const struct __ns3__GetJpeg *)ptr);
00411 break;
00412 case SOAP_TYPE___ns3__Revisions:
00413 soap_serialize___ns3__Revisions(soap, (const struct __ns3__Revisions *)ptr);
00414 break;
00415 case SOAP_TYPE___ns2__DimeJpeg:
00416 soap_serialize___ns2__DimeJpeg(soap, (const struct __ns2__DimeJpeg *)ptr);
00417 break;
00418 case SOAP_TYPE___ns2__GetJpegQuery:
00419 soap_serialize___ns2__GetJpegQuery(soap, (const struct __ns2__GetJpegQuery *)ptr);
00420 break;
00421 case SOAP_TYPE___ns2__GetJpeg:
00422 soap_serialize___ns2__GetJpeg(soap, (const struct __ns2__GetJpeg *)ptr);
00423 break;
00424 case SOAP_TYPE___ns2__Revisions:
00425 soap_serialize___ns2__Revisions(soap, (const struct __ns2__Revisions *)ptr);
00426 break;
00427 case SOAP_TYPE__ns1__DimeJpegResponse:
00428 soap_serialize__ns1__DimeJpegResponse(soap, (const struct _ns1__DimeJpegResponse *)ptr);
00429 break;
00430 case SOAP_TYPE__ns1__DimeJpeg:
00431 soap_serialize__ns1__DimeJpeg(soap, (const struct _ns1__DimeJpeg *)ptr);
00432 break;
00433 case SOAP_TYPE__ns1__GetJpegQueryResponse:
00434 soap_serialize__ns1__GetJpegQueryResponse(soap, (const struct _ns1__GetJpegQueryResponse *)ptr);
00435 break;
00436 case SOAP_TYPE__ns1__GetJpegQuery:
00437 soap_serialize__ns1__GetJpegQuery(soap, (const struct _ns1__GetJpegQuery *)ptr);
00438 break;
00439 case SOAP_TYPE__ns1__GetJpegResponse:
00440 soap_serialize__ns1__GetJpegResponse(soap, (const struct _ns1__GetJpegResponse *)ptr);
00441 break;
00442 case SOAP_TYPE__ns1__GetJpeg:
00443 soap_serialize__ns1__GetJpeg(soap, (const struct _ns1__GetJpeg *)ptr);
00444 break;
00445 case SOAP_TYPE__ns1__RevisionsResponse:
00446 soap_serialize__ns1__RevisionsResponse(soap, (const struct _ns1__RevisionsResponse *)ptr);
00447 break;
00448 case SOAP_TYPE__ns1__Revisions:
00449 soap_serialize__ns1__Revisions(soap, (const struct _ns1__Revisions *)ptr);
00450 break;
00451 case SOAP_TYPE_ns1__ArrayOfString:
00452 soap_serialize_ns1__ArrayOfString(soap, (const struct ns1__ArrayOfString *)ptr);
00453 break;
00454 case SOAP_TYPE_xsd__base64Binary:
00455 soap_serialize_xsd__base64Binary(soap, (const struct xsd__base64Binary *)ptr);
00456 break;
00457 case SOAP_TYPE_PointerTo_ns1__DimeJpegResponse:
00458 soap_serialize_PointerTo_ns1__DimeJpegResponse(soap, (struct _ns1__DimeJpegResponse *const*)ptr);
00459 break;
00460 case SOAP_TYPE_PointerTo_ns1__DimeJpeg:
00461 soap_serialize_PointerTo_ns1__DimeJpeg(soap, (struct _ns1__DimeJpeg *const*)ptr);
00462 break;
00463 case SOAP_TYPE_PointerTo_ns1__GetJpegQueryResponse:
00464 soap_serialize_PointerTo_ns1__GetJpegQueryResponse(soap, (struct _ns1__GetJpegQueryResponse *const*)ptr);
00465 break;
00466 case SOAP_TYPE_PointerTo_ns1__GetJpegQuery:
00467 soap_serialize_PointerTo_ns1__GetJpegQuery(soap, (struct _ns1__GetJpegQuery *const*)ptr);
00468 break;
00469 case SOAP_TYPE_PointerTo_ns1__GetJpegResponse:
00470 soap_serialize_PointerTo_ns1__GetJpegResponse(soap, (struct _ns1__GetJpegResponse *const*)ptr);
00471 break;
00472 case SOAP_TYPE_PointerTo_ns1__GetJpeg:
00473 soap_serialize_PointerTo_ns1__GetJpeg(soap, (struct _ns1__GetJpeg *const*)ptr);
00474 break;
00475 case SOAP_TYPE_PointerTo_ns1__RevisionsResponse:
00476 soap_serialize_PointerTo_ns1__RevisionsResponse(soap, (struct _ns1__RevisionsResponse *const*)ptr);
00477 break;
00478 case SOAP_TYPE_PointerTo_ns1__Revisions:
00479 soap_serialize_PointerTo_ns1__Revisions(soap, (struct _ns1__Revisions *const*)ptr);
00480 break;
00481 case SOAP_TYPE_PointerToxsd__base64Binary:
00482 soap_serialize_PointerToxsd__base64Binary(soap, (struct xsd__base64Binary *const*)ptr);
00483 break;
00484 case SOAP_TYPE_PointerTons1__ArrayOfString:
00485 soap_serialize_PointerTons1__ArrayOfString(soap, (struct ns1__ArrayOfString *const*)ptr);
00486 break;
00487 case SOAP_TYPE_PointerTostring:
00488 soap_serialize_PointerTostring(soap, (char **const*)ptr);
00489 break;
00490 case SOAP_TYPE_PointerTounsignedByte:
00491 soap_serialize_PointerTounsignedByte(soap, (unsigned char *const*)ptr);
00492 break;
00493 case SOAP_TYPE__QName:
00494 soap_serialize_string(soap, (char*const*)&ptr);
00495 break;
00496 case SOAP_TYPE_string:
00497 soap_serialize_string(soap, (char*const*)&ptr);
00498 break;
00499 }
00500 }
00501 #endif
00502
00503 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00504 { (void)soap;
00505 #ifdef SOAP_DEFAULT_byte
00506 *a = SOAP_DEFAULT_byte;
00507 #else
00508 *a = (char)0;
00509 #endif
00510 }
00511
00512 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00513 {
00514 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00515 if (soap_out_byte(soap, tag, id, a, type))
00516 return soap->error;
00517 return soap_putindependent(soap);
00518 }
00519
00520 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00521 {
00522 return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00523 }
00524
00525 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00526 {
00527 if ((p = soap_in_byte(soap, tag, p, type)))
00528 if (soap_getindependent(soap))
00529 return NULL;
00530 return p;
00531 }
00532
00533 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00534 {
00535 return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00536 }
00537
00538 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00539 { (void)soap;
00540 #ifdef SOAP_DEFAULT_int
00541 *a = SOAP_DEFAULT_int;
00542 #else
00543 *a = (int)0;
00544 #endif
00545 }
00546
00547 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00548 {
00549 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00550 if (soap_out_int(soap, tag, id, a, type))
00551 return soap->error;
00552 return soap_putindependent(soap);
00553 }
00554
00555 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
00556 {
00557 return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
00558 }
00559
00560 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00561 {
00562 if ((p = soap_in_int(soap, tag, p, type)))
00563 if (soap_getindependent(soap))
00564 return NULL;
00565 return p;
00566 }
00567
00568 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00569 {
00570 return soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00571 }
00572
00573 SOAP_FMAC3 void SOAP_FMAC4 soap_default_double(struct soap *soap, double *a)
00574 { (void)soap;
00575 #ifdef SOAP_DEFAULT_double
00576 *a = SOAP_DEFAULT_double;
00577 #else
00578 *a = (double)0;
00579 #endif
00580 }
00581
00582 SOAP_FMAC3 int SOAP_FMAC4 soap_put_double(struct soap *soap, const double *a, const char *tag, const char *type)
00583 {
00584 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_double);
00585 if (soap_out_double(soap, tag, id, a, type))
00586 return soap->error;
00587 return soap_putindependent(soap);
00588 }
00589
00590 SOAP_FMAC3 int SOAP_FMAC4 soap_out_double(struct soap *soap, const char *tag, int id, const double *a, const char *type)
00591 {
00592 return soap_outdouble(soap, tag, id, a, type, SOAP_TYPE_double);
00593 }
00594
00595 SOAP_FMAC3 double * SOAP_FMAC4 soap_get_double(struct soap *soap, double *p, const char *tag, const char *type)
00596 {
00597 if ((p = soap_in_double(soap, tag, p, type)))
00598 if (soap_getindependent(soap))
00599 return NULL;
00600 return p;
00601 }
00602
00603 SOAP_FMAC3 double * SOAP_FMAC4 soap_in_double(struct soap *soap, const char *tag, double *a, const char *type)
00604 {
00605 return soap_indouble(soap, tag, a, type, SOAP_TYPE_double);
00606 }
00607
00608 SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedByte(struct soap *soap, unsigned char *a)
00609 { (void)soap;
00610 #ifdef SOAP_DEFAULT_unsignedByte
00611 *a = SOAP_DEFAULT_unsignedByte;
00612 #else
00613 *a = (unsigned char)0;
00614 #endif
00615 }
00616
00617 SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedByte(struct soap *soap, const unsigned char *a, const char *tag, const char *type)
00618 {
00619 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_unsignedByte);
00620 if (soap_out_unsignedByte(soap, tag, id, a, type))
00621 return soap->error;
00622 return soap_putindependent(soap);
00623 }
00624
00625 SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type)
00626 {
00627 return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_unsignedByte);
00628 }
00629
00630 SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_unsignedByte(struct soap *soap, unsigned char *p, const char *tag, const char *type)
00631 {
00632 if ((p = soap_in_unsignedByte(soap, tag, p, type)))
00633 if (soap_getindependent(soap))
00634 return NULL;
00635 return p;
00636 }
00637
00638 SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_unsignedByte(struct soap *soap, const char *tag, unsigned char *a, const char *type)
00639 {
00640 return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_unsignedByte);
00641 }
00642
00643 SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedInt(struct soap *soap, unsigned int *a)
00644 { (void)soap;
00645 #ifdef SOAP_DEFAULT_unsignedInt
00646 *a = SOAP_DEFAULT_unsignedInt;
00647 #else
00648 *a = (unsigned int)0;
00649 #endif
00650 }
00651
00652 SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedInt(struct soap *soap, const unsigned int *a, const char *tag, const char *type)
00653 {
00654 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_unsignedInt);
00655 if (soap_out_unsignedInt(soap, tag, id, a, type))
00656 return soap->error;
00657 return soap_putindependent(soap);
00658 }
00659
00660 SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type)
00661 {
00662 return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_unsignedInt);
00663 }
00664
00665 SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_unsignedInt(struct soap *soap, unsigned int *p, const char *tag, const char *type)
00666 {
00667 if ((p = soap_in_unsignedInt(soap, tag, p, type)))
00668 if (soap_getindependent(soap))
00669 return NULL;
00670 return p;
00671 }
00672
00673 SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_unsignedInt(struct soap *soap, const char *tag, unsigned int *a, const char *type)
00674 {
00675 return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_unsignedInt);
00676 }
00677
00678 #ifndef WITH_NOGLOBAL
00679
00680 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
00681 {
00682 (void)soap; (void)a;
00683 soap_default__QName(soap, &a->faultcode);
00684 soap_default_string(soap, &a->faultstring);
00685 soap_default_string(soap, &a->faultactor);
00686 a->detail = NULL;
00687 a->SOAP_ENV__Code = NULL;
00688 a->SOAP_ENV__Reason = NULL;
00689 soap_default_string(soap, &a->SOAP_ENV__Node);
00690 soap_default_string(soap, &a->SOAP_ENV__Role);
00691 a->SOAP_ENV__Detail = NULL;
00692 }
00693
00694 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
00695 {
00696 (void)soap; (void)a;
00697 soap_serialize__QName(soap, &a->faultcode);
00698 soap_serialize_string(soap, &a->faultstring);
00699 soap_serialize_string(soap, &a->faultactor);
00700 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
00701 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
00702 soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
00703 soap_serialize_string(soap, &a->SOAP_ENV__Node);
00704 soap_serialize_string(soap, &a->SOAP_ENV__Role);
00705 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
00706 }
00707
00708 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)
00709 {
00710 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
00711 if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type))
00712 return soap->error;
00713 return soap_putindependent(soap);
00714 }
00715
00716 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)
00717 {
00718 const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
00719 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
00720 return soap->error;
00721 if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
00722 return soap->error;
00723 if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
00724 return soap->error;
00725 if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
00726 return soap->error;
00727 if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
00728 return soap->error;
00729 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
00730 return soap->error;
00731 if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
00732 return soap->error;
00733 if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
00734 return soap->error;
00735 if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
00736 return soap->error;
00737 if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
00738 return soap->error;
00739 return soap_element_end_out(soap, tag);
00740 }
00741
00742 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)
00743 {
00744 if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
00745 if (soap_getindependent(soap))
00746 return NULL;
00747 return p;
00748 }
00749
00750 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)
00751 {
00752 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;
00753 if (soap_element_begin_in(soap, tag, 0, type))
00754 return NULL;
00755 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);
00756 if (!a)
00757 return NULL;
00758 soap_default_SOAP_ENV__Fault(soap, a);
00759 if (soap->body && !*soap->href)
00760 {
00761 for (;;)
00762 { soap->error = SOAP_TAG_MISMATCH;
00763 if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00764 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
00765 { soap_flag_faultcode--;
00766 continue;
00767 }
00768 if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00769 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
00770 { soap_flag_faultstring--;
00771 continue;
00772 }
00773 if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00774 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
00775 { soap_flag_faultactor--;
00776 continue;
00777 }
00778 if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
00779 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
00780 { soap_flag_detail--;
00781 continue;
00782 }
00783 if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
00784 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
00785 { soap_flag_SOAP_ENV__Code--;
00786 continue;
00787 }
00788 if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
00789 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
00790 { soap_flag_SOAP_ENV__Reason--;
00791 continue;
00792 }
00793 if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00794 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
00795 { soap_flag_SOAP_ENV__Node--;
00796 continue;
00797 }
00798 if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00799 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
00800 { soap_flag_SOAP_ENV__Role--;
00801 continue;
00802 }
00803 if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
00804 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
00805 { soap_flag_SOAP_ENV__Detail--;
00806 continue;
00807 }
00808 if (soap->error == SOAP_TAG_MISMATCH)
00809 soap->error = soap_ignore_element(soap);
00810 if (soap->error == SOAP_NO_TAG)
00811 break;
00812 if (soap->error)
00813 return NULL;
00814 }
00815 if (soap_element_end_in(soap, tag))
00816 return NULL;
00817 }
00818 else
00819 { 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);
00820 if (soap->body && soap_element_end_in(soap, tag))
00821 return NULL;
00822 }
00823 return a;
00824 }
00825
00826 #endif
00827
00828 #ifndef WITH_NOGLOBAL
00829
00830 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
00831 {
00832 (void)soap; (void)a;
00833 soap_default_string(soap, &a->SOAP_ENV__Text);
00834 }
00835
00836 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
00837 {
00838 (void)soap; (void)a;
00839 soap_serialize_string(soap, &a->SOAP_ENV__Text);
00840 }
00841
00842 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)
00843 {
00844 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
00845 if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type))
00846 return soap->error;
00847 return soap_putindependent(soap);
00848 }
00849
00850 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)
00851 {
00852 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
00853 return soap->error;
00854 if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
00855 return soap->error;
00856 return soap_element_end_out(soap, tag);
00857 }
00858
00859 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)
00860 {
00861 if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
00862 if (soap_getindependent(soap))
00863 return NULL;
00864 return p;
00865 }
00866
00867 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)
00868 {
00869 short soap_flag_SOAP_ENV__Text = 1;
00870 if (soap_element_begin_in(soap, tag, 0, type))
00871 return NULL;
00872 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);
00873 if (!a)
00874 return NULL;
00875 soap_default_SOAP_ENV__Reason(soap, a);
00876 if (soap->body && !*soap->href)
00877 {
00878 for (;;)
00879 { soap->error = SOAP_TAG_MISMATCH;
00880 if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00881 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
00882 { soap_flag_SOAP_ENV__Text--;
00883 continue;
00884 }
00885 if (soap->error == SOAP_TAG_MISMATCH)
00886 soap->error = soap_ignore_element(soap);
00887 if (soap->error == SOAP_NO_TAG)
00888 break;
00889 if (soap->error)
00890 return NULL;
00891 }
00892 if (soap_element_end_in(soap, tag))
00893 return NULL;
00894 }
00895 else
00896 { 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);
00897 if (soap->body && soap_element_end_in(soap, tag))
00898 return NULL;
00899 }
00900 return a;
00901 }
00902
00903 #endif
00904
00905 #ifndef WITH_NOGLOBAL
00906
00907 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
00908 {
00909 (void)soap; (void)a;
00910 a->__type = 0;
00911 a->fault = NULL;
00912 a->__any = NULL;
00913 }
00914
00915 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
00916 {
00917 (void)soap; (void)a;
00918 soap_markelement(soap, a->fault, a->__type);
00919 }
00920
00921 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)
00922 {
00923 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
00924 if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type))
00925 return soap->error;
00926 return soap_putindependent(soap);
00927 }
00928
00929 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)
00930 {
00931 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
00932 return soap->error;
00933 if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
00934 return soap->error;
00935 soap_outliteral(soap, "-any", &a->__any, NULL);
00936 return soap_element_end_out(soap, tag);
00937 }
00938
00939 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)
00940 {
00941 if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
00942 if (soap_getindependent(soap))
00943 return NULL;
00944 return p;
00945 }
00946
00947 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)
00948 {
00949 short soap_flag_fault = 1, soap_flag___any = 1;
00950 if (soap_element_begin_in(soap, tag, 0, type))
00951 return NULL;
00952 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);
00953 if (!a)
00954 return NULL;
00955 soap_default_SOAP_ENV__Detail(soap, a);
00956 if (soap->body && !*soap->href)
00957 {
00958 for (;;)
00959 { soap->error = SOAP_TAG_MISMATCH;
00960 if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
00961 if ((a->fault = soap_getelement(soap, &a->__type)))
00962 { soap_flag_fault = 0;
00963 continue;
00964 }
00965 if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00966 if (soap_inliteral(soap, "-any", &a->__any))
00967 { soap_flag___any--;
00968 continue;
00969 }
00970 if (soap->error == SOAP_TAG_MISMATCH)
00971 soap->error = soap_ignore_element(soap);
00972 if (soap->error == SOAP_NO_TAG)
00973 break;
00974 if (soap->error)
00975 return NULL;
00976 }
00977 if (soap_element_end_in(soap, tag))
00978 return NULL;
00979 }
00980 else
00981 { 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);
00982 if (soap->body && soap_element_end_in(soap, tag))
00983 return NULL;
00984 }
00985 return a;
00986 }
00987
00988 #endif
00989
00990 #ifndef WITH_NOGLOBAL
00991
00992 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
00993 {
00994 (void)soap; (void)a;
00995 soap_default__QName(soap, &a->SOAP_ENV__Value);
00996 a->SOAP_ENV__Subcode = NULL;
00997 }
00998
00999 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
01000 {
01001 (void)soap; (void)a;
01002 soap_serialize__QName(soap, &a->SOAP_ENV__Value);
01003 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
01004 }
01005
01006 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)
01007 {
01008 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
01009 if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type))
01010 return soap->error;
01011 return soap_putindependent(soap);
01012 }
01013
01014 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)
01015 {
01016 const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
01017 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
01018 return soap->error;
01019 if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
01020 return soap->error;
01021 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
01022 return soap->error;
01023 return soap_element_end_out(soap, tag);
01024 }
01025
01026 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)
01027 {
01028 if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
01029 if (soap_getindependent(soap))
01030 return NULL;
01031 return p;
01032 }
01033
01034 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)
01035 {
01036 short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1;
01037 if (soap_element_begin_in(soap, tag, 0, type))
01038 return NULL;
01039 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);
01040 if (!a)
01041 return NULL;
01042 soap_default_SOAP_ENV__Code(soap, a);
01043 if (soap->body && !*soap->href)
01044 {
01045 for (;;)
01046 { soap->error = SOAP_TAG_MISMATCH;
01047 if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01048 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
01049 { soap_flag_SOAP_ENV__Value--;
01050 continue;
01051 }
01052 if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
01053 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
01054 { soap_flag_SOAP_ENV__Subcode--;
01055 continue;
01056 }
01057 if (soap->error == SOAP_TAG_MISMATCH)
01058 soap->error = soap_ignore_element(soap);
01059 if (soap->error == SOAP_NO_TAG)
01060 break;
01061 if (soap->error)
01062 return NULL;
01063 }
01064 if (soap_element_end_in(soap, tag))
01065 return NULL;
01066 }
01067 else
01068 { 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);
01069 if (soap->body && soap_element_end_in(soap, tag))
01070 return NULL;
01071 }
01072 return a;
01073 }
01074
01075 #endif
01076
01077 #ifndef WITH_NOGLOBAL
01078
01079 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
01080 {
01081 (void)soap; (void)a;
01082 }
01083
01084 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
01085 {
01086 (void)soap; (void)a;
01087 }
01088
01089 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)
01090 {
01091 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
01092 if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type))
01093 return soap->error;
01094 return soap_putindependent(soap);
01095 }
01096
01097 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)
01098 {
01099 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
01100 return soap->error;
01101 return soap_element_end_out(soap, tag);
01102 }
01103
01104 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)
01105 {
01106 if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
01107 if (soap_getindependent(soap))
01108 return NULL;
01109 return p;
01110 }
01111
01112 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)
01113 {
01114 if (soap_element_begin_in(soap, tag, 0, type))
01115 return NULL;
01116 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);
01117 if (!a)
01118 return NULL;
01119 soap_default_SOAP_ENV__Header(soap, a);
01120 if (soap->body && !*soap->href)
01121 {
01122 for (;;)
01123 { soap->error = SOAP_TAG_MISMATCH;
01124 if (soap->error == SOAP_TAG_MISMATCH)
01125 soap->error = soap_ignore_element(soap);
01126 if (soap->error == SOAP_NO_TAG)
01127 break;
01128 if (soap->error)
01129 return NULL;
01130 }
01131 if (soap_element_end_in(soap, tag))
01132 return NULL;
01133 }
01134 else
01135 { 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);
01136 if (soap->body && soap_element_end_in(soap, tag))
01137 return NULL;
01138 }
01139 return a;
01140 }
01141
01142 #endif
01143
01144 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__DimeJpeg(struct soap *soap, struct __ns3__DimeJpeg *a)
01145 {
01146 (void)soap; (void)a;
01147 a->ns1__DimeJpeg = NULL;
01148 }
01149
01150 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__DimeJpeg(struct soap *soap, const struct __ns3__DimeJpeg *a)
01151 {
01152 (void)soap; (void)a;
01153 soap_serialize_PointerTo_ns1__DimeJpeg(soap, &a->ns1__DimeJpeg);
01154 }
01155
01156 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__DimeJpeg(struct soap *soap, const struct __ns3__DimeJpeg *a, const char *tag, const char *type)
01157 {
01158 register int id = 0;
01159 if (soap_out___ns3__DimeJpeg(soap, tag, id, a, type))
01160 return soap->error;
01161 return SOAP_OK;
01162 }
01163
01164 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__DimeJpeg(struct soap *soap, const char *tag, int id, const struct __ns3__DimeJpeg *a, const char *type)
01165 {
01166 if (soap_out_PointerTo_ns1__DimeJpeg(soap, "ns1:DimeJpeg", -1, &a->ns1__DimeJpeg, ""))
01167 return soap->error;
01168 return SOAP_OK;
01169 }
01170
01171 SOAP_FMAC3 struct __ns3__DimeJpeg * SOAP_FMAC4 soap_get___ns3__DimeJpeg(struct soap *soap, struct __ns3__DimeJpeg *p, const char *tag, const char *type)
01172 {
01173 if ((p = soap_in___ns3__DimeJpeg(soap, tag, p, type)))
01174 if (soap_getindependent(soap))
01175 return NULL;
01176 return p;
01177 }
01178
01179 SOAP_FMAC3 struct __ns3__DimeJpeg * SOAP_FMAC4 soap_in___ns3__DimeJpeg(struct soap *soap, const char *tag, struct __ns3__DimeJpeg *a, const char *type)
01180 {
01181 short soap_flag_ns1__DimeJpeg = 1;
01182 short soap_flag;
01183 a = (struct __ns3__DimeJpeg *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__DimeJpeg, sizeof(struct __ns3__DimeJpeg), 0, NULL, NULL, NULL);
01184 if (!a)
01185 return NULL;
01186 soap_default___ns3__DimeJpeg(soap, a);
01187 for (soap_flag = 0;; soap_flag = 1)
01188 { soap->error = SOAP_TAG_MISMATCH;
01189 if (soap_flag_ns1__DimeJpeg && soap->error == SOAP_TAG_MISMATCH)
01190 if (soap_in_PointerTo_ns1__DimeJpeg(soap, "ns1:DimeJpeg", &a->ns1__DimeJpeg, ""))
01191 { soap_flag_ns1__DimeJpeg--;
01192 continue;
01193 }
01194 if (soap->error == SOAP_TAG_MISMATCH)
01195 if (soap_flag)
01196 { soap->error = SOAP_OK;
01197 break;
01198 }
01199 if (soap->error == SOAP_NO_TAG)
01200 break;
01201 if (soap->error)
01202 return NULL;
01203 }
01204 return a;
01205 }
01206
01207 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__GetJpegQuery(struct soap *soap, struct __ns3__GetJpegQuery *a)
01208 {
01209 (void)soap; (void)a;
01210 a->ns1__GetJpegQuery = NULL;
01211 }
01212
01213 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__GetJpegQuery(struct soap *soap, const struct __ns3__GetJpegQuery *a)
01214 {
01215 (void)soap; (void)a;
01216 soap_serialize_PointerTo_ns1__GetJpegQuery(soap, &a->ns1__GetJpegQuery);
01217 }
01218
01219 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__GetJpegQuery(struct soap *soap, const struct __ns3__GetJpegQuery *a, const char *tag, const char *type)
01220 {
01221 register int id = 0;
01222 if (soap_out___ns3__GetJpegQuery(soap, tag, id, a, type))
01223 return soap->error;
01224 return SOAP_OK;
01225 }
01226
01227 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__GetJpegQuery(struct soap *soap, const char *tag, int id, const struct __ns3__GetJpegQuery *a, const char *type)
01228 {
01229 if (soap_out_PointerTo_ns1__GetJpegQuery(soap, "ns1:GetJpegQuery", -1, &a->ns1__GetJpegQuery, ""))
01230 return soap->error;
01231 return SOAP_OK;
01232 }
01233
01234 SOAP_FMAC3 struct __ns3__GetJpegQuery * SOAP_FMAC4 soap_get___ns3__GetJpegQuery(struct soap *soap, struct __ns3__GetJpegQuery *p, const char *tag, const char *type)
01235 {
01236 if ((p = soap_in___ns3__GetJpegQuery(soap, tag, p, type)))
01237 if (soap_getindependent(soap))
01238 return NULL;
01239 return p;
01240 }
01241
01242 SOAP_FMAC3 struct __ns3__GetJpegQuery * SOAP_FMAC4 soap_in___ns3__GetJpegQuery(struct soap *soap, const char *tag, struct __ns3__GetJpegQuery *a, const char *type)
01243 {
01244 short soap_flag_ns1__GetJpegQuery = 1;
01245 short soap_flag;
01246 a = (struct __ns3__GetJpegQuery *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__GetJpegQuery, sizeof(struct __ns3__GetJpegQuery), 0, NULL, NULL, NULL);
01247 if (!a)
01248 return NULL;
01249 soap_default___ns3__GetJpegQuery(soap, a);
01250 for (soap_flag = 0;; soap_flag = 1)
01251 { soap->error = SOAP_TAG_MISMATCH;
01252 if (soap_flag_ns1__GetJpegQuery && soap->error == SOAP_TAG_MISMATCH)
01253 if (soap_in_PointerTo_ns1__GetJpegQuery(soap, "ns1:GetJpegQuery", &a->ns1__GetJpegQuery, ""))
01254 { soap_flag_ns1__GetJpegQuery--;
01255 continue;
01256 }
01257 if (soap->error == SOAP_TAG_MISMATCH)
01258 if (soap_flag)
01259 { soap->error = SOAP_OK;
01260 break;
01261 }
01262 if (soap->error == SOAP_NO_TAG)
01263 break;
01264 if (soap->error)
01265 return NULL;
01266 }
01267 return a;
01268 }
01269
01270 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__GetJpeg(struct soap *soap, struct __ns3__GetJpeg *a)
01271 {
01272 (void)soap; (void)a;
01273 a->ns1__GetJpeg = NULL;
01274 }
01275
01276 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__GetJpeg(struct soap *soap, const struct __ns3__GetJpeg *a)
01277 {
01278 (void)soap; (void)a;
01279 soap_serialize_PointerTo_ns1__GetJpeg(soap, &a->ns1__GetJpeg);
01280 }
01281
01282 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__GetJpeg(struct soap *soap, const struct __ns3__GetJpeg *a, const char *tag, const char *type)
01283 {
01284 register int id = 0;
01285 if (soap_out___ns3__GetJpeg(soap, tag, id, a, type))
01286 return soap->error;
01287 return SOAP_OK;
01288 }
01289
01290 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__GetJpeg(struct soap *soap, const char *tag, int id, const struct __ns3__GetJpeg *a, const char *type)
01291 {
01292 if (soap_out_PointerTo_ns1__GetJpeg(soap, "ns1:GetJpeg", -1, &a->ns1__GetJpeg, ""))
01293 return soap->error;
01294 return SOAP_OK;
01295 }
01296
01297 SOAP_FMAC3 struct __ns3__GetJpeg * SOAP_FMAC4 soap_get___ns3__GetJpeg(struct soap *soap, struct __ns3__GetJpeg *p, const char *tag, const char *type)
01298 {
01299 if ((p = soap_in___ns3__GetJpeg(soap, tag, p, type)))
01300 if (soap_getindependent(soap))
01301 return NULL;
01302 return p;
01303 }
01304
01305 SOAP_FMAC3 struct __ns3__GetJpeg * SOAP_FMAC4 soap_in___ns3__GetJpeg(struct soap *soap, const char *tag, struct __ns3__GetJpeg *a, const char *type)
01306 {
01307 short soap_flag_ns1__GetJpeg = 1;
01308 short soap_flag;
01309 a = (struct __ns3__GetJpeg *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__GetJpeg, sizeof(struct __ns3__GetJpeg), 0, NULL, NULL, NULL);
01310 if (!a)
01311 return NULL;
01312 soap_default___ns3__GetJpeg(soap, a);
01313 for (soap_flag = 0;; soap_flag = 1)
01314 { soap->error = SOAP_TAG_MISMATCH;
01315 if (soap_flag_ns1__GetJpeg && soap->error == SOAP_TAG_MISMATCH)
01316 if (soap_in_PointerTo_ns1__GetJpeg(soap, "ns1:GetJpeg", &a->ns1__GetJpeg, ""))
01317 { soap_flag_ns1__GetJpeg--;
01318 continue;
01319 }
01320 if (soap->error == SOAP_TAG_MISMATCH)
01321 if (soap_flag)
01322 { soap->error = SOAP_OK;
01323 break;
01324 }
01325 if (soap->error == SOAP_NO_TAG)
01326 break;
01327 if (soap->error)
01328 return NULL;
01329 }
01330 return a;
01331 }
01332
01333 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__Revisions(struct soap *soap, struct __ns3__Revisions *a)
01334 {
01335 (void)soap; (void)a;
01336 a->ns1__Revisions = NULL;
01337 }
01338
01339 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__Revisions(struct soap *soap, const struct __ns3__Revisions *a)
01340 {
01341 (void)soap; (void)a;
01342 soap_serialize_PointerTo_ns1__Revisions(soap, &a->ns1__Revisions);
01343 }
01344
01345 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__Revisions(struct soap *soap, const struct __ns3__Revisions *a, const char *tag, const char *type)
01346 {
01347 register int id = 0;
01348 if (soap_out___ns3__Revisions(soap, tag, id, a, type))
01349 return soap->error;
01350 return SOAP_OK;
01351 }
01352
01353 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__Revisions(struct soap *soap, const char *tag, int id, const struct __ns3__Revisions *a, const char *type)
01354 {
01355 if (soap_out_PointerTo_ns1__Revisions(soap, "ns1:Revisions", -1, &a->ns1__Revisions, ""))
01356 return soap->error;
01357 return SOAP_OK;
01358 }
01359
01360 SOAP_FMAC3 struct __ns3__Revisions * SOAP_FMAC4 soap_get___ns3__Revisions(struct soap *soap, struct __ns3__Revisions *p, const char *tag, const char *type)
01361 {
01362 if ((p = soap_in___ns3__Revisions(soap, tag, p, type)))
01363 if (soap_getindependent(soap))
01364 return NULL;
01365 return p;
01366 }
01367
01368 SOAP_FMAC3 struct __ns3__Revisions * SOAP_FMAC4 soap_in___ns3__Revisions(struct soap *soap, const char *tag, struct __ns3__Revisions *a, const char *type)
01369 {
01370 short soap_flag_ns1__Revisions = 1;
01371 short soap_flag;
01372 a = (struct __ns3__Revisions *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__Revisions, sizeof(struct __ns3__Revisions), 0, NULL, NULL, NULL);
01373 if (!a)
01374 return NULL;
01375 soap_default___ns3__Revisions(soap, a);
01376 for (soap_flag = 0;; soap_flag = 1)
01377 { soap->error = SOAP_TAG_MISMATCH;
01378 if (soap_flag_ns1__Revisions && soap->error == SOAP_TAG_MISMATCH)
01379 if (soap_in_PointerTo_ns1__Revisions(soap, "ns1:Revisions", &a->ns1__Revisions, ""))
01380 { soap_flag_ns1__Revisions--;
01381 continue;
01382 }
01383 if (soap->error == SOAP_TAG_MISMATCH)
01384 if (soap_flag)
01385 { soap->error = SOAP_OK;
01386 break;
01387 }
01388 if (soap->error == SOAP_NO_TAG)
01389 break;
01390 if (soap->error)
01391 return NULL;
01392 }
01393 return a;
01394 }
01395
01396 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__DimeJpeg(struct soap *soap, struct __ns2__DimeJpeg *a)
01397 {
01398 (void)soap; (void)a;
01399 a->ns1__DimeJpeg = NULL;
01400 }
01401
01402 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__DimeJpeg(struct soap *soap, const struct __ns2__DimeJpeg *a)
01403 {
01404 (void)soap; (void)a;
01405 soap_serialize_PointerTo_ns1__DimeJpeg(soap, &a->ns1__DimeJpeg);
01406 }
01407
01408 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__DimeJpeg(struct soap *soap, const struct __ns2__DimeJpeg *a, const char *tag, const char *type)
01409 {
01410 register int id = 0;
01411 if (soap_out___ns2__DimeJpeg(soap, tag, id, a, type))
01412 return soap->error;
01413 return SOAP_OK;
01414 }
01415
01416 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__DimeJpeg(struct soap *soap, const char *tag, int id, const struct __ns2__DimeJpeg *a, const char *type)
01417 {
01418 if (soap_out_PointerTo_ns1__DimeJpeg(soap, "ns1:DimeJpeg", -1, &a->ns1__DimeJpeg, ""))
01419 return soap->error;
01420 return SOAP_OK;
01421 }
01422
01423 SOAP_FMAC3 struct __ns2__DimeJpeg * SOAP_FMAC4 soap_get___ns2__DimeJpeg(struct soap *soap, struct __ns2__DimeJpeg *p, const char *tag, const char *type)
01424 {
01425 if ((p = soap_in___ns2__DimeJpeg(soap, tag, p, type)))
01426 if (soap_getindependent(soap))
01427 return NULL;
01428 return p;
01429 }
01430
01431 SOAP_FMAC3 struct __ns2__DimeJpeg * SOAP_FMAC4 soap_in___ns2__DimeJpeg(struct soap *soap, const char *tag, struct __ns2__DimeJpeg *a, const char *type)
01432 {
01433 short soap_flag_ns1__DimeJpeg = 1;
01434 short soap_flag;
01435 a = (struct __ns2__DimeJpeg *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__DimeJpeg, sizeof(struct __ns2__DimeJpeg), 0, NULL, NULL, NULL);
01436 if (!a)
01437 return NULL;
01438 soap_default___ns2__DimeJpeg(soap, a);
01439 for (soap_flag = 0;; soap_flag = 1)
01440 { soap->error = SOAP_TAG_MISMATCH;
01441 if (soap_flag_ns1__DimeJpeg && soap->error == SOAP_TAG_MISMATCH)
01442 if (soap_in_PointerTo_ns1__DimeJpeg(soap, "ns1:DimeJpeg", &a->ns1__DimeJpeg, ""))
01443 { soap_flag_ns1__DimeJpeg--;
01444 continue;
01445 }
01446 if (soap->error == SOAP_TAG_MISMATCH)
01447 if (soap_flag)
01448 { soap->error = SOAP_OK;
01449 break;
01450 }
01451 if (soap->error == SOAP_NO_TAG)
01452 break;
01453 if (soap->error)
01454 return NULL;
01455 }
01456 return a;
01457 }
01458
01459 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__GetJpegQuery(struct soap *soap, struct __ns2__GetJpegQuery *a)
01460 {
01461 (void)soap; (void)a;
01462 a->ns1__GetJpegQuery = NULL;
01463 }
01464
01465 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__GetJpegQuery(struct soap *soap, const struct __ns2__GetJpegQuery *a)
01466 {
01467 (void)soap; (void)a;
01468 soap_serialize_PointerTo_ns1__GetJpegQuery(soap, &a->ns1__GetJpegQuery);
01469 }
01470
01471 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__GetJpegQuery(struct soap *soap, const struct __ns2__GetJpegQuery *a, const char *tag, const char *type)
01472 {
01473 register int id = 0;
01474 if (soap_out___ns2__GetJpegQuery(soap, tag, id, a, type))
01475 return soap->error;
01476 return SOAP_OK;
01477 }
01478
01479 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__GetJpegQuery(struct soap *soap, const char *tag, int id, const struct __ns2__GetJpegQuery *a, const char *type)
01480 {
01481 if (soap_out_PointerTo_ns1__GetJpegQuery(soap, "ns1:GetJpegQuery", -1, &a->ns1__GetJpegQuery, ""))
01482 return soap->error;
01483 return SOAP_OK;
01484 }
01485
01486 SOAP_FMAC3 struct __ns2__GetJpegQuery * SOAP_FMAC4 soap_get___ns2__GetJpegQuery(struct soap *soap, struct __ns2__GetJpegQuery *p, const char *tag, const char *type)
01487 {
01488 if ((p = soap_in___ns2__GetJpegQuery(soap, tag, p, type)))
01489 if (soap_getindependent(soap))
01490 return NULL;
01491 return p;
01492 }
01493
01494 SOAP_FMAC3 struct __ns2__GetJpegQuery * SOAP_FMAC4 soap_in___ns2__GetJpegQuery(struct soap *soap, const char *tag, struct __ns2__GetJpegQuery *a, const char *type)
01495 {
01496 short soap_flag_ns1__GetJpegQuery = 1;
01497 short soap_flag;
01498 a = (struct __ns2__GetJpegQuery *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__GetJpegQuery, sizeof(struct __ns2__GetJpegQuery), 0, NULL, NULL, NULL);
01499 if (!a)
01500 return NULL;
01501 soap_default___ns2__GetJpegQuery(soap, a);
01502 for (soap_flag = 0;; soap_flag = 1)
01503 { soap->error = SOAP_TAG_MISMATCH;
01504 if (soap_flag_ns1__GetJpegQuery && soap->error == SOAP_TAG_MISMATCH)
01505 if (soap_in_PointerTo_ns1__GetJpegQuery(soap, "ns1:GetJpegQuery", &a->ns1__GetJpegQuery, ""))
01506 { soap_flag_ns1__GetJpegQuery--;
01507 continue;
01508 }
01509 if (soap->error == SOAP_TAG_MISMATCH)
01510 if (soap_flag)
01511 { soap->error = SOAP_OK;
01512 break;
01513 }
01514 if (soap->error == SOAP_NO_TAG)
01515 break;
01516 if (soap->error)
01517 return NULL;
01518 }
01519 return a;
01520 }
01521
01522 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__GetJpeg(struct soap *soap, struct __ns2__GetJpeg *a)
01523 {
01524 (void)soap; (void)a;
01525 a->ns1__GetJpeg = NULL;
01526 }
01527
01528 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__GetJpeg(struct soap *soap, const struct __ns2__GetJpeg *a)
01529 {
01530 (void)soap; (void)a;
01531 soap_serialize_PointerTo_ns1__GetJpeg(soap, &a->ns1__GetJpeg);
01532 }
01533
01534 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__GetJpeg(struct soap *soap, const struct __ns2__GetJpeg *a, const char *tag, const char *type)
01535 {
01536 register int id = 0;
01537 if (soap_out___ns2__GetJpeg(soap, tag, id, a, type))
01538 return soap->error;
01539 return SOAP_OK;
01540 }
01541
01542 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__GetJpeg(struct soap *soap, const char *tag, int id, const struct __ns2__GetJpeg *a, const char *type)
01543 {
01544 if (soap_out_PointerTo_ns1__GetJpeg(soap, "ns1:GetJpeg", -1, &a->ns1__GetJpeg, ""))
01545 return soap->error;
01546 return SOAP_OK;
01547 }
01548
01549 SOAP_FMAC3 struct __ns2__GetJpeg * SOAP_FMAC4 soap_get___ns2__GetJpeg(struct soap *soap, struct __ns2__GetJpeg *p, const char *tag, const char *type)
01550 {
01551 if ((p = soap_in___ns2__GetJpeg(soap, tag, p, type)))
01552 if (soap_getindependent(soap))
01553 return NULL;
01554 return p;
01555 }
01556
01557 SOAP_FMAC3 struct __ns2__GetJpeg * SOAP_FMAC4 soap_in___ns2__GetJpeg(struct soap *soap, const char *tag, struct __ns2__GetJpeg *a, const char *type)
01558 {
01559 short soap_flag_ns1__GetJpeg = 1;
01560 short soap_flag;
01561 a = (struct __ns2__GetJpeg *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__GetJpeg, sizeof(struct __ns2__GetJpeg), 0, NULL, NULL, NULL);
01562 if (!a)
01563 return NULL;
01564 soap_default___ns2__GetJpeg(soap, a);
01565 for (soap_flag = 0;; soap_flag = 1)
01566 { soap->error = SOAP_TAG_MISMATCH;
01567 if (soap_flag_ns1__GetJpeg && soap->error == SOAP_TAG_MISMATCH)
01568 if (soap_in_PointerTo_ns1__GetJpeg(soap, "ns1:GetJpeg", &a->ns1__GetJpeg, ""))
01569 { soap_flag_ns1__GetJpeg--;
01570 continue;
01571 }
01572 if (soap->error == SOAP_TAG_MISMATCH)
01573 if (soap_flag)
01574 { soap->error = SOAP_OK;
01575 break;
01576 }
01577 if (soap->error == SOAP_NO_TAG)
01578 break;
01579 if (soap->error)
01580 return NULL;
01581 }
01582 return a;
01583 }
01584
01585 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__Revisions(struct soap *soap, struct __ns2__Revisions *a)
01586 {
01587 (void)soap; (void)a;
01588 a->ns1__Revisions = NULL;
01589 }
01590
01591 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__Revisions(struct soap *soap, const struct __ns2__Revisions *a)
01592 {
01593 (void)soap; (void)a;
01594 soap_serialize_PointerTo_ns1__Revisions(soap, &a->ns1__Revisions);
01595 }
01596
01597 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__Revisions(struct soap *soap, const struct __ns2__Revisions *a, const char *tag, const char *type)
01598 {
01599 register int id = 0;
01600 if (soap_out___ns2__Revisions(soap, tag, id, a, type))
01601 return soap->error;
01602 return SOAP_OK;
01603 }
01604
01605 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__Revisions(struct soap *soap, const char *tag, int id, const struct __ns2__Revisions *a, const char *type)
01606 {
01607 if (soap_out_PointerTo_ns1__Revisions(soap, "ns1:Revisions", -1, &a->ns1__Revisions, ""))
01608 return soap->error;
01609 return SOAP_OK;
01610 }
01611
01612 SOAP_FMAC3 struct __ns2__Revisions * SOAP_FMAC4 soap_get___ns2__Revisions(struct soap *soap, struct __ns2__Revisions *p, const char *tag, const char *type)
01613 {
01614 if ((p = soap_in___ns2__Revisions(soap, tag, p, type)))
01615 if (soap_getindependent(soap))
01616 return NULL;
01617 return p;
01618 }
01619
01620 SOAP_FMAC3 struct __ns2__Revisions * SOAP_FMAC4 soap_in___ns2__Revisions(struct soap *soap, const char *tag, struct __ns2__Revisions *a, const char *type)
01621 {
01622 short soap_flag_ns1__Revisions = 1;
01623 short soap_flag;
01624 a = (struct __ns2__Revisions *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__Revisions, sizeof(struct __ns2__Revisions), 0, NULL, NULL, NULL);
01625 if (!a)
01626 return NULL;
01627 soap_default___ns2__Revisions(soap, a);
01628 for (soap_flag = 0;; soap_flag = 1)
01629 { soap->error = SOAP_TAG_MISMATCH;
01630 if (soap_flag_ns1__Revisions && soap->error == SOAP_TAG_MISMATCH)
01631 if (soap_in_PointerTo_ns1__Revisions(soap, "ns1:Revisions", &a->ns1__Revisions, ""))
01632 { soap_flag_ns1__Revisions--;
01633 continue;
01634 }
01635 if (soap->error == SOAP_TAG_MISMATCH)
01636 if (soap_flag)
01637 { soap->error = SOAP_OK;
01638 break;
01639 }
01640 if (soap->error == SOAP_NO_TAG)
01641 break;
01642 if (soap->error)
01643 return NULL;
01644 }
01645 return a;
01646 }
01647
01648 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__DimeJpegResponse(struct soap *soap, struct _ns1__DimeJpegResponse *a)
01649 {
01650 (void)soap; (void)a;
01651 }
01652
01653 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__DimeJpegResponse(struct soap *soap, const struct _ns1__DimeJpegResponse *a)
01654 {
01655 (void)soap; (void)a;
01656 }
01657
01658 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__DimeJpegResponse(struct soap *soap, const struct _ns1__DimeJpegResponse *a, const char *tag, const char *type)
01659 {
01660 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__DimeJpegResponse);
01661 if (soap_out__ns1__DimeJpegResponse(soap, tag, id, a, type))
01662 return soap->error;
01663 return soap_putindependent(soap);
01664 }
01665
01666 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__DimeJpegResponse(struct soap *soap, const char *tag, int id, const struct _ns1__DimeJpegResponse *a, const char *type)
01667 {
01668 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__DimeJpegResponse), type))
01669 return soap->error;
01670 return soap_element_end_out(soap, tag);
01671 }
01672
01673 SOAP_FMAC3 struct _ns1__DimeJpegResponse * SOAP_FMAC4 soap_get__ns1__DimeJpegResponse(struct soap *soap, struct _ns1__DimeJpegResponse *p, const char *tag, const char *type)
01674 {
01675 if ((p = soap_in__ns1__DimeJpegResponse(soap, tag, p, type)))
01676 if (soap_getindependent(soap))
01677 return NULL;
01678 return p;
01679 }
01680
01681 SOAP_FMAC3 struct _ns1__DimeJpegResponse * SOAP_FMAC4 soap_in__ns1__DimeJpegResponse(struct soap *soap, const char *tag, struct _ns1__DimeJpegResponse *a, const char *type)
01682 {
01683 if (soap_element_begin_in(soap, tag, 0, type))
01684 return NULL;
01685 a = (struct _ns1__DimeJpegResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__DimeJpegResponse, sizeof(struct _ns1__DimeJpegResponse), 0, NULL, NULL, NULL);
01686 if (!a)
01687 return NULL;
01688 soap_default__ns1__DimeJpegResponse(soap, a);
01689 if (soap->body && !*soap->href)
01690 {
01691 for (;;)
01692 { soap->error = SOAP_TAG_MISMATCH;
01693 if (soap->error == SOAP_TAG_MISMATCH)
01694 soap->error = soap_ignore_element(soap);
01695 if (soap->error == SOAP_NO_TAG)
01696 break;
01697 if (soap->error)
01698 return NULL;
01699 }
01700 if (soap_element_end_in(soap, tag))
01701 return NULL;
01702 }
01703 else
01704 { a = (struct _ns1__DimeJpegResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__DimeJpegResponse, 0, sizeof(struct _ns1__DimeJpegResponse), 0, NULL);
01705 if (soap->body && soap_element_end_in(soap, tag))
01706 return NULL;
01707 }
01708 return a;
01709 }
01710
01711 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__DimeJpeg(struct soap *soap, struct _ns1__DimeJpeg *a)
01712 {
01713 (void)soap; (void)a;
01714 soap_default_double(soap, &a->ra_USCORE);
01715 soap_default_double(soap, &a->dec_USCORE);
01716 soap_default_double(soap, &a->scale_USCORE);
01717 soap_default_int(soap, &a->width_USCORE);
01718 soap_default_int(soap, &a->height_USCORE);
01719 soap_default_string(soap, &a->opt_USCORE);
01720 }
01721
01722 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__DimeJpeg(struct soap *soap, const struct _ns1__DimeJpeg *a)
01723 {
01724 (void)soap; (void)a;
01725 soap_serialize_string(soap, &a->opt_USCORE);
01726 }
01727
01728 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__DimeJpeg(struct soap *soap, const struct _ns1__DimeJpeg *a, const char *tag, const char *type)
01729 {
01730 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__DimeJpeg);
01731 if (soap_out__ns1__DimeJpeg(soap, tag, id, a, type))
01732 return soap->error;
01733 return soap_putindependent(soap);
01734 }
01735
01736 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__DimeJpeg(struct soap *soap, const char *tag, int id, const struct _ns1__DimeJpeg *a, const char *type)
01737 {
01738 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__DimeJpeg), type))
01739 return soap->error;
01740 if (soap_out_double(soap, "ns1:ra_", -1, &a->ra_USCORE, ""))
01741 return soap->error;
01742 if (soap_out_double(soap, "ns1:dec_", -1, &a->dec_USCORE, ""))
01743 return soap->error;
01744 if (soap_out_double(soap, "ns1:scale_", -1, &a->scale_USCORE, ""))
01745 return soap->error;
01746 if (soap_out_int(soap, "ns1:width_", -1, &a->width_USCORE, ""))
01747 return soap->error;
01748 if (soap_out_int(soap, "ns1:height_", -1, &a->height_USCORE, ""))
01749 return soap->error;
01750 if (soap_out_string(soap, "ns1:opt_", -1, &a->opt_USCORE, ""))
01751 return soap->error;
01752 return soap_element_end_out(soap, tag);
01753 }
01754
01755 SOAP_FMAC3 struct _ns1__DimeJpeg * SOAP_FMAC4 soap_get__ns1__DimeJpeg(struct soap *soap, struct _ns1__DimeJpeg *p, const char *tag, const char *type)
01756 {
01757 if ((p = soap_in__ns1__DimeJpeg(soap, tag, p, type)))
01758 if (soap_getindependent(soap))
01759 return NULL;
01760 return p;
01761 }
01762
01763 SOAP_FMAC3 struct _ns1__DimeJpeg * SOAP_FMAC4 soap_in__ns1__DimeJpeg(struct soap *soap, const char *tag, struct _ns1__DimeJpeg *a, const char *type)
01764 {
01765 short soap_flag_ra_USCORE = 1, soap_flag_dec_USCORE = 1, soap_flag_scale_USCORE = 1, soap_flag_width_USCORE = 1, soap_flag_height_USCORE = 1, soap_flag_opt_USCORE = 1;
01766 if (soap_element_begin_in(soap, tag, 0, type))
01767 return NULL;
01768 a = (struct _ns1__DimeJpeg *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__DimeJpeg, sizeof(struct _ns1__DimeJpeg), 0, NULL, NULL, NULL);
01769 if (!a)
01770 return NULL;
01771 soap_default__ns1__DimeJpeg(soap, a);
01772 if (soap->body && !*soap->href)
01773 {
01774 for (;;)
01775 { soap->error = SOAP_TAG_MISMATCH;
01776 if (soap_flag_ra_USCORE && soap->error == SOAP_TAG_MISMATCH)
01777 if (soap_in_double(soap, "ns1:ra_", &a->ra_USCORE, "xsd:double"))
01778 { soap_flag_ra_USCORE--;
01779 continue;
01780 }
01781 if (soap_flag_dec_USCORE && soap->error == SOAP_TAG_MISMATCH)
01782 if (soap_in_double(soap, "ns1:dec_", &a->dec_USCORE, "xsd:double"))
01783 { soap_flag_dec_USCORE--;
01784 continue;
01785 }
01786 if (soap_flag_scale_USCORE && soap->error == SOAP_TAG_MISMATCH)
01787 if (soap_in_double(soap, "ns1:scale_", &a->scale_USCORE, "xsd:double"))
01788 { soap_flag_scale_USCORE--;
01789 continue;
01790 }
01791 if (soap_flag_width_USCORE && soap->error == SOAP_TAG_MISMATCH)
01792 if (soap_in_int(soap, "ns1:width_", &a->width_USCORE, "xsd:int"))
01793 { soap_flag_width_USCORE--;
01794 continue;
01795 }
01796 if (soap_flag_height_USCORE && soap->error == SOAP_TAG_MISMATCH)
01797 if (soap_in_int(soap, "ns1:height_", &a->height_USCORE, "xsd:int"))
01798 { soap_flag_height_USCORE--;
01799 continue;
01800 }
01801 if (soap_flag_opt_USCORE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01802 if (soap_in_string(soap, "ns1:opt_", &a->opt_USCORE, "xsd:string"))
01803 { soap_flag_opt_USCORE--;
01804 continue;
01805 }
01806 if (soap->error == SOAP_TAG_MISMATCH)
01807 soap->error = soap_ignore_element(soap);
01808 if (soap->error == SOAP_NO_TAG)
01809 break;
01810 if (soap->error)
01811 return NULL;
01812 }
01813 if (soap_element_end_in(soap, tag))
01814 return NULL;
01815 }
01816 else
01817 { a = (struct _ns1__DimeJpeg *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__DimeJpeg, 0, sizeof(struct _ns1__DimeJpeg), 0, NULL);
01818 if (soap->body && soap_element_end_in(soap, tag))
01819 return NULL;
01820 }
01821 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ra_USCORE > 0 || soap_flag_dec_USCORE > 0 || soap_flag_scale_USCORE > 0 || soap_flag_width_USCORE > 0 || soap_flag_height_USCORE > 0))
01822 { soap->error = SOAP_OCCURS;
01823 return NULL;
01824 }
01825 return a;
01826 }
01827
01828 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__GetJpegQueryResponse(struct soap *soap, struct _ns1__GetJpegQueryResponse *a)
01829 {
01830 (void)soap; (void)a;
01831 a->GetJpegQueryResult = NULL;
01832 }
01833
01834 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__GetJpegQueryResponse(struct soap *soap, const struct _ns1__GetJpegQueryResponse *a)
01835 {
01836 (void)soap; (void)a;
01837 soap_serialize_PointerToxsd__base64Binary(soap, &a->GetJpegQueryResult);
01838 }
01839
01840 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__GetJpegQueryResponse(struct soap *soap, const struct _ns1__GetJpegQueryResponse *a, const char *tag, const char *type)
01841 {
01842 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__GetJpegQueryResponse);
01843 if (soap_out__ns1__GetJpegQueryResponse(soap, tag, id, a, type))
01844 return soap->error;
01845 return soap_putindependent(soap);
01846 }
01847
01848 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__GetJpegQueryResponse(struct soap *soap, const char *tag, int id, const struct _ns1__GetJpegQueryResponse *a, const char *type)
01849 {
01850 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__GetJpegQueryResponse), type))
01851 return soap->error;
01852 if (a->GetJpegQueryResult)
01853 soap_element_result(soap, "ns1:GetJpegQueryResult");
01854 if (soap_out_PointerToxsd__base64Binary(soap, "ns1:GetJpegQueryResult", -1, &a->GetJpegQueryResult, ""))
01855 return soap->error;
01856 return soap_element_end_out(soap, tag);
01857 }
01858
01859 SOAP_FMAC3 struct _ns1__GetJpegQueryResponse * SOAP_FMAC4 soap_get__ns1__GetJpegQueryResponse(struct soap *soap, struct _ns1__GetJpegQueryResponse *p, const char *tag, const char *type)
01860 {
01861 if ((p = soap_in__ns1__GetJpegQueryResponse(soap, tag, p, type)))
01862 if (soap_getindependent(soap))
01863 return NULL;
01864 return p;
01865 }
01866
01867 SOAP_FMAC3 struct _ns1__GetJpegQueryResponse * SOAP_FMAC4 soap_in__ns1__GetJpegQueryResponse(struct soap *soap, const char *tag, struct _ns1__GetJpegQueryResponse *a, const char *type)
01868 {
01869 short soap_flag_GetJpegQueryResult = 1;
01870 if (soap_element_begin_in(soap, tag, 0, type))
01871 return NULL;
01872 a = (struct _ns1__GetJpegQueryResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__GetJpegQueryResponse, sizeof(struct _ns1__GetJpegQueryResponse), 0, NULL, NULL, NULL);
01873 if (!a)
01874 return NULL;
01875 soap_default__ns1__GetJpegQueryResponse(soap, a);
01876 if (soap->body && !*soap->href)
01877 {
01878 for (;;)
01879 { soap->error = SOAP_TAG_MISMATCH;
01880 if (soap_flag_GetJpegQueryResult && soap->error == SOAP_TAG_MISMATCH)
01881 if (soap_in_PointerToxsd__base64Binary(soap, "ns1:GetJpegQueryResult", &a->GetJpegQueryResult, "xsd:base64Binary"))
01882 { soap_flag_GetJpegQueryResult--;
01883 continue;
01884 }
01885 soap_check_result(soap, "ns1:GetJpegQueryResult");
01886 if (soap->error == SOAP_TAG_MISMATCH)
01887 soap->error = soap_ignore_element(soap);
01888 if (soap->error == SOAP_NO_TAG)
01889 break;
01890 if (soap->error)
01891 return NULL;
01892 }
01893 if (soap_element_end_in(soap, tag))
01894 return NULL;
01895 }
01896 else
01897 { a = (struct _ns1__GetJpegQueryResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__GetJpegQueryResponse, 0, sizeof(struct _ns1__GetJpegQueryResponse), 0, NULL);
01898 if (soap->body && soap_element_end_in(soap, tag))
01899 return NULL;
01900 }
01901 return a;
01902 }
01903
01904 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__GetJpegQuery(struct soap *soap, struct _ns1__GetJpegQuery *a)
01905 {
01906 (void)soap; (void)a;
01907 soap_default_double(soap, &a->ra_USCORE);
01908 soap_default_double(soap, &a->dec_USCORE);
01909 soap_default_double(soap, &a->scale_USCORE);
01910 soap_default_int(soap, &a->width_USCORE);
01911 soap_default_int(soap, &a->height_USCORE);
01912 soap_default_string(soap, &a->opt_USCORE);
01913 soap_default_string(soap, &a->query_USCORE);
01914 }
01915
01916 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__GetJpegQuery(struct soap *soap, const struct _ns1__GetJpegQuery *a)
01917 {
01918 (void)soap; (void)a;
01919 soap_serialize_string(soap, &a->opt_USCORE);
01920 soap_serialize_string(soap, &a->query_USCORE);
01921 }
01922
01923 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__GetJpegQuery(struct soap *soap, const struct _ns1__GetJpegQuery *a, const char *tag, const char *type)
01924 {
01925 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__GetJpegQuery);
01926 if (soap_out__ns1__GetJpegQuery(soap, tag, id, a, type))
01927 return soap->error;
01928 return soap_putindependent(soap);
01929 }
01930
01931 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__GetJpegQuery(struct soap *soap, const char *tag, int id, const struct _ns1__GetJpegQuery *a, const char *type)
01932 {
01933 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__GetJpegQuery), type))
01934 return soap->error;
01935 if (soap_out_double(soap, "ns1:ra_", -1, &a->ra_USCORE, ""))
01936 return soap->error;
01937 if (soap_out_double(soap, "ns1:dec_", -1, &a->dec_USCORE, ""))
01938 return soap->error;
01939 if (soap_out_double(soap, "ns1:scale_", -1, &a->scale_USCORE, ""))
01940 return soap->error;
01941 if (soap_out_int(soap, "ns1:width_", -1, &a->width_USCORE, ""))
01942 return soap->error;
01943 if (soap_out_int(soap, "ns1:height_", -1, &a->height_USCORE, ""))
01944 return soap->error;
01945 if (soap_out_string(soap, "ns1:opt_", -1, &a->opt_USCORE, ""))
01946 return soap->error;
01947 if (soap_out_string(soap, "ns1:query_", -1, &a->query_USCORE, ""))
01948 return soap->error;
01949 return soap_element_end_out(soap, tag);
01950 }
01951
01952 SOAP_FMAC3 struct _ns1__GetJpegQuery * SOAP_FMAC4 soap_get__ns1__GetJpegQuery(struct soap *soap, struct _ns1__GetJpegQuery *p, const char *tag, const char *type)
01953 {
01954 if ((p = soap_in__ns1__GetJpegQuery(soap, tag, p, type)))
01955 if (soap_getindependent(soap))
01956 return NULL;
01957 return p;
01958 }
01959
01960 SOAP_FMAC3 struct _ns1__GetJpegQuery * SOAP_FMAC4 soap_in__ns1__GetJpegQuery(struct soap *soap, const char *tag, struct _ns1__GetJpegQuery *a, const char *type)
01961 {
01962 short soap_flag_ra_USCORE = 1, soap_flag_dec_USCORE = 1, soap_flag_scale_USCORE = 1, soap_flag_width_USCORE = 1, soap_flag_height_USCORE = 1, soap_flag_opt_USCORE = 1, soap_flag_query_USCORE = 1;
01963 if (soap_element_begin_in(soap, tag, 0, type))
01964 return NULL;
01965 a = (struct _ns1__GetJpegQuery *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__GetJpegQuery, sizeof(struct _ns1__GetJpegQuery), 0, NULL, NULL, NULL);
01966 if (!a)
01967 return NULL;
01968 soap_default__ns1__GetJpegQuery(soap, a);
01969 if (soap->body && !*soap->href)
01970 {
01971 for (;;)
01972 { soap->error = SOAP_TAG_MISMATCH;
01973 if (soap_flag_ra_USCORE && soap->error == SOAP_TAG_MISMATCH)
01974 if (soap_in_double(soap, "ns1:ra_", &a->ra_USCORE, "xsd:double"))
01975 { soap_flag_ra_USCORE--;
01976 continue;
01977 }
01978 if (soap_flag_dec_USCORE && soap->error == SOAP_TAG_MISMATCH)
01979 if (soap_in_double(soap, "ns1:dec_", &a->dec_USCORE, "xsd:double"))
01980 { soap_flag_dec_USCORE--;
01981 continue;
01982 }
01983 if (soap_flag_scale_USCORE && soap->error == SOAP_TAG_MISMATCH)
01984 if (soap_in_double(soap, "ns1:scale_", &a->scale_USCORE, "xsd:double"))
01985 { soap_flag_scale_USCORE--;
01986 continue;
01987 }
01988 if (soap_flag_width_USCORE && soap->error == SOAP_TAG_MISMATCH)
01989 if (soap_in_int(soap, "ns1:width_", &a->width_USCORE, "xsd:int"))
01990 { soap_flag_width_USCORE--;
01991 continue;
01992 }
01993 if (soap_flag_height_USCORE && soap->error == SOAP_TAG_MISMATCH)
01994 if (soap_in_int(soap, "ns1:height_", &a->height_USCORE, "xsd:int"))
01995 { soap_flag_height_USCORE--;
01996 continue;
01997 }
01998 if (soap_flag_opt_USCORE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01999 if (soap_in_string(soap, "ns1:opt_", &a->opt_USCORE, "xsd:string"))
02000 { soap_flag_opt_USCORE--;
02001 continue;
02002 }
02003 if (soap_flag_query_USCORE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02004 if (soap_in_string(soap, "ns1:query_", &a->query_USCORE, "xsd:string"))
02005 { soap_flag_query_USCORE--;
02006 continue;
02007 }
02008 if (soap->error == SOAP_TAG_MISMATCH)
02009 soap->error = soap_ignore_element(soap);
02010 if (soap->error == SOAP_NO_TAG)
02011 break;
02012 if (soap->error)
02013 return NULL;
02014 }
02015 if (soap_element_end_in(soap, tag))
02016 return NULL;
02017 }
02018 else
02019 { a = (struct _ns1__GetJpegQuery *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__GetJpegQuery, 0, sizeof(struct _ns1__GetJpegQuery), 0, NULL);
02020 if (soap->body && soap_element_end_in(soap, tag))
02021 return NULL;
02022 }
02023 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ra_USCORE > 0 || soap_flag_dec_USCORE > 0 || soap_flag_scale_USCORE > 0 || soap_flag_width_USCORE > 0 || soap_flag_height_USCORE > 0))
02024 { soap->error = SOAP_OCCURS;
02025 return NULL;
02026 }
02027 return a;
02028 }
02029
02030 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__GetJpegResponse(struct soap *soap, struct _ns1__GetJpegResponse *a)
02031 {
02032 (void)soap; (void)a;
02033 a->GetJpegResult = NULL;
02034 }
02035
02036 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__GetJpegResponse(struct soap *soap, const struct _ns1__GetJpegResponse *a)
02037 {
02038 (void)soap; (void)a;
02039 soap_serialize_PointerToxsd__base64Binary(soap, &a->GetJpegResult);
02040 }
02041
02042 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__GetJpegResponse(struct soap *soap, const struct _ns1__GetJpegResponse *a, const char *tag, const char *type)
02043 {
02044 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__GetJpegResponse);
02045 if (soap_out__ns1__GetJpegResponse(soap, tag, id, a, type))
02046 return soap->error;
02047 return soap_putindependent(soap);
02048 }
02049
02050 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__GetJpegResponse(struct soap *soap, const char *tag, int id, const struct _ns1__GetJpegResponse *a, const char *type)
02051 {
02052 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__GetJpegResponse), type))
02053 return soap->error;
02054 if (a->GetJpegResult)
02055 soap_element_result(soap, "ns1:GetJpegResult");
02056 if (soap_out_PointerToxsd__base64Binary(soap, "ns1:GetJpegResult", -1, &a->GetJpegResult, ""))
02057 return soap->error;
02058 return soap_element_end_out(soap, tag);
02059 }
02060
02061 SOAP_FMAC3 struct _ns1__GetJpegResponse * SOAP_FMAC4 soap_get__ns1__GetJpegResponse(struct soap *soap, struct _ns1__GetJpegResponse *p, const char *tag, const char *type)
02062 {
02063 if ((p = soap_in__ns1__GetJpegResponse(soap, tag, p, type)))
02064 if (soap_getindependent(soap))
02065 return NULL;
02066 return p;
02067 }
02068
02069 SOAP_FMAC3 struct _ns1__GetJpegResponse * SOAP_FMAC4 soap_in__ns1__GetJpegResponse(struct soap *soap, const char *tag, struct _ns1__GetJpegResponse *a, const char *type)
02070 {
02071 short soap_flag_GetJpegResult = 1;
02072 if (soap_element_begin_in(soap, tag, 0, type))
02073 return NULL;
02074 a = (struct _ns1__GetJpegResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__GetJpegResponse, sizeof(struct _ns1__GetJpegResponse), 0, NULL, NULL, NULL);
02075 if (!a)
02076 return NULL;
02077 soap_default__ns1__GetJpegResponse(soap, a);
02078 if (soap->body && !*soap->href)
02079 {
02080 for (;;)
02081 { soap->error = SOAP_TAG_MISMATCH;
02082 if (soap_flag_GetJpegResult && soap->error == SOAP_TAG_MISMATCH)
02083 if (soap_in_PointerToxsd__base64Binary(soap, "ns1:GetJpegResult", &a->GetJpegResult, "xsd:base64Binary"))
02084 { soap_flag_GetJpegResult--;
02085 continue;
02086 }
02087 soap_check_result(soap, "ns1:GetJpegResult");
02088 if (soap->error == SOAP_TAG_MISMATCH)
02089 soap->error = soap_ignore_element(soap);
02090 if (soap->error == SOAP_NO_TAG)
02091 break;
02092 if (soap->error)
02093 return NULL;
02094 }
02095 if (soap_element_end_in(soap, tag))
02096 return NULL;
02097 }
02098 else
02099 { a = (struct _ns1__GetJpegResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__GetJpegResponse, 0, sizeof(struct _ns1__GetJpegResponse), 0, NULL);
02100 if (soap->body && soap_element_end_in(soap, tag))
02101 return NULL;
02102 }
02103 return a;
02104 }
02105
02106 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__GetJpeg(struct soap *soap, struct _ns1__GetJpeg *a)
02107 {
02108 (void)soap; (void)a;
02109 soap_default_double(soap, &a->ra_USCORE);
02110 soap_default_double(soap, &a->dec_USCORE);
02111 soap_default_double(soap, &a->scale_USCORE);
02112 soap_default_int(soap, &a->width_USCORE);
02113 soap_default_int(soap, &a->height_USCORE);
02114 soap_default_string(soap, &a->opt_USCORE);
02115 }
02116
02117 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__GetJpeg(struct soap *soap, const struct _ns1__GetJpeg *a)
02118 {
02119 (void)soap; (void)a;
02120 soap_serialize_string(soap, &a->opt_USCORE);
02121 }
02122
02123 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__GetJpeg(struct soap *soap, const struct _ns1__GetJpeg *a, const char *tag, const char *type)
02124 {
02125 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__GetJpeg);
02126 if (soap_out__ns1__GetJpeg(soap, tag, id, a, type))
02127 return soap->error;
02128 return soap_putindependent(soap);
02129 }
02130
02131 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__GetJpeg(struct soap *soap, const char *tag, int id, const struct _ns1__GetJpeg *a, const char *type)
02132 {
02133 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__GetJpeg), type))
02134 return soap->error;
02135 if (soap_out_double(soap, "ns1:ra_", -1, &a->ra_USCORE, ""))
02136 return soap->error;
02137 if (soap_out_double(soap, "ns1:dec_", -1, &a->dec_USCORE, ""))
02138 return soap->error;
02139 if (soap_out_double(soap, "ns1:scale_", -1, &a->scale_USCORE, ""))
02140 return soap->error;
02141 if (soap_out_int(soap, "ns1:width_", -1, &a->width_USCORE, ""))
02142 return soap->error;
02143 if (soap_out_int(soap, "ns1:height_", -1, &a->height_USCORE, ""))
02144 return soap->error;
02145 if (soap_out_string(soap, "ns1:opt_", -1, &a->opt_USCORE, ""))
02146 return soap->error;
02147 return soap_element_end_out(soap, tag);
02148 }
02149
02150 SOAP_FMAC3 struct _ns1__GetJpeg * SOAP_FMAC4 soap_get__ns1__GetJpeg(struct soap *soap, struct _ns1__GetJpeg *p, const char *tag, const char *type)
02151 {
02152 if ((p = soap_in__ns1__GetJpeg(soap, tag, p, type)))
02153 if (soap_getindependent(soap))
02154 return NULL;
02155 return p;
02156 }
02157
02158 SOAP_FMAC3 struct _ns1__GetJpeg * SOAP_FMAC4 soap_in__ns1__GetJpeg(struct soap *soap, const char *tag, struct _ns1__GetJpeg *a, const char *type)
02159 {
02160 short soap_flag_ra_USCORE = 1, soap_flag_dec_USCORE = 1, soap_flag_scale_USCORE = 1, soap_flag_width_USCORE = 1, soap_flag_height_USCORE = 1, soap_flag_opt_USCORE = 1;
02161 if (soap_element_begin_in(soap, tag, 0, type))
02162 return NULL;
02163 a = (struct _ns1__GetJpeg *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__GetJpeg, sizeof(struct _ns1__GetJpeg), 0, NULL, NULL, NULL);
02164 if (!a)
02165 return NULL;
02166 soap_default__ns1__GetJpeg(soap, a);
02167 if (soap->body && !*soap->href)
02168 {
02169 for (;;)
02170 { soap->error = SOAP_TAG_MISMATCH;
02171 if (soap_flag_ra_USCORE && soap->error == SOAP_TAG_MISMATCH)
02172 if (soap_in_double(soap, "ns1:ra_", &a->ra_USCORE, "xsd:double"))
02173 { soap_flag_ra_USCORE--;
02174 continue;
02175 }
02176 if (soap_flag_dec_USCORE && soap->error == SOAP_TAG_MISMATCH)
02177 if (soap_in_double(soap, "ns1:dec_", &a->dec_USCORE, "xsd:double"))
02178 { soap_flag_dec_USCORE--;
02179 continue;
02180 }
02181 if (soap_flag_scale_USCORE && soap->error == SOAP_TAG_MISMATCH)
02182 if (soap_in_double(soap, "ns1:scale_", &a->scale_USCORE, "xsd:double"))
02183 { soap_flag_scale_USCORE--;
02184 continue;
02185 }
02186 if (soap_flag_width_USCORE && soap->error == SOAP_TAG_MISMATCH)
02187 if (soap_in_int(soap, "ns1:width_", &a->width_USCORE, "xsd:int"))
02188 { soap_flag_width_USCORE--;
02189 continue;
02190 }
02191 if (soap_flag_height_USCORE && soap->error == SOAP_TAG_MISMATCH)
02192 if (soap_in_int(soap, "ns1:height_", &a->height_USCORE, "xsd:int"))
02193 { soap_flag_height_USCORE--;
02194 continue;
02195 }
02196 if (soap_flag_opt_USCORE && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02197 if (soap_in_string(soap, "ns1:opt_", &a->opt_USCORE, "xsd:string"))
02198 { soap_flag_opt_USCORE--;
02199 continue;
02200 }
02201 if (soap->error == SOAP_TAG_MISMATCH)
02202 soap->error = soap_ignore_element(soap);
02203 if (soap->error == SOAP_NO_TAG)
02204 break;
02205 if (soap->error)
02206 return NULL;
02207 }
02208 if (soap_element_end_in(soap, tag))
02209 return NULL;
02210 }
02211 else
02212 { a = (struct _ns1__GetJpeg *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__GetJpeg, 0, sizeof(struct _ns1__GetJpeg), 0, NULL);
02213 if (soap->body && soap_element_end_in(soap, tag))
02214 return NULL;
02215 }
02216 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ra_USCORE > 0 || soap_flag_dec_USCORE > 0 || soap_flag_scale_USCORE > 0 || soap_flag_width_USCORE > 0 || soap_flag_height_USCORE > 0))
02217 { soap->error = SOAP_OCCURS;
02218 return NULL;
02219 }
02220 return a;
02221 }
02222
02223 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *a)
02224 {
02225 (void)soap; (void)a;
02226 a->RevisionsResult = NULL;
02227 }
02228
02229 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__RevisionsResponse(struct soap *soap, const struct _ns1__RevisionsResponse *a)
02230 {
02231 (void)soap; (void)a;
02232 soap_serialize_PointerTons1__ArrayOfString(soap, &a->RevisionsResult);
02233 }
02234
02235 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__RevisionsResponse(struct soap *soap, const struct _ns1__RevisionsResponse *a, const char *tag, const char *type)
02236 {
02237 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__RevisionsResponse);
02238 if (soap_out__ns1__RevisionsResponse(soap, tag, id, a, type))
02239 return soap->error;
02240 return soap_putindependent(soap);
02241 }
02242
02243 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__RevisionsResponse(struct soap *soap, const char *tag, int id, const struct _ns1__RevisionsResponse *a, const char *type)
02244 {
02245 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__RevisionsResponse), type))
02246 return soap->error;
02247 if (a->RevisionsResult)
02248 soap_element_result(soap, "ns1:RevisionsResult");
02249 if (soap_out_PointerTons1__ArrayOfString(soap, "ns1:RevisionsResult", -1, &a->RevisionsResult, ""))
02250 return soap->error;
02251 return soap_element_end_out(soap, tag);
02252 }
02253
02254 SOAP_FMAC3 struct _ns1__RevisionsResponse * SOAP_FMAC4 soap_get__ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *p, const char *tag, const char *type)
02255 {
02256 if ((p = soap_in__ns1__RevisionsResponse(soap, tag, p, type)))
02257 if (soap_getindependent(soap))
02258 return NULL;
02259 return p;
02260 }
02261
02262 SOAP_FMAC3 struct _ns1__RevisionsResponse * SOAP_FMAC4 soap_in__ns1__RevisionsResponse(struct soap *soap, const char *tag, struct _ns1__RevisionsResponse *a, const char *type)
02263 {
02264 short soap_flag_RevisionsResult = 1;
02265 if (soap_element_begin_in(soap, tag, 0, type))
02266 return NULL;
02267 a = (struct _ns1__RevisionsResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__RevisionsResponse, sizeof(struct _ns1__RevisionsResponse), 0, NULL, NULL, NULL);
02268 if (!a)
02269 return NULL;
02270 soap_default__ns1__RevisionsResponse(soap, a);
02271 if (soap->body && !*soap->href)
02272 {
02273 for (;;)
02274 { soap->error = SOAP_TAG_MISMATCH;
02275 if (soap_flag_RevisionsResult && soap->error == SOAP_TAG_MISMATCH)
02276 if (soap_in_PointerTons1__ArrayOfString(soap, "ns1:RevisionsResult", &a->RevisionsResult, "ns1:ArrayOfString"))
02277 { soap_flag_RevisionsResult--;
02278 continue;
02279 }
02280 soap_check_result(soap, "ns1:RevisionsResult");
02281 if (soap->error == SOAP_TAG_MISMATCH)
02282 soap->error = soap_ignore_element(soap);
02283 if (soap->error == SOAP_NO_TAG)
02284 break;
02285 if (soap->error)
02286 return NULL;
02287 }
02288 if (soap_element_end_in(soap, tag))
02289 return NULL;
02290 }
02291 else
02292 { a = (struct _ns1__RevisionsResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__RevisionsResponse, 0, sizeof(struct _ns1__RevisionsResponse), 0, NULL);
02293 if (soap->body && soap_element_end_in(soap, tag))
02294 return NULL;
02295 }
02296 return a;
02297 }
02298
02299 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__Revisions(struct soap *soap, struct _ns1__Revisions *a)
02300 {
02301 (void)soap; (void)a;
02302 }
02303
02304 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__Revisions(struct soap *soap, const struct _ns1__Revisions *a)
02305 {
02306 (void)soap; (void)a;
02307 }
02308
02309 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__Revisions(struct soap *soap, const struct _ns1__Revisions *a, const char *tag, const char *type)
02310 {
02311 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__Revisions);
02312 if (soap_out__ns1__Revisions(soap, tag, id, a, type))
02313 return soap->error;
02314 return soap_putindependent(soap);
02315 }
02316
02317 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__Revisions(struct soap *soap, const char *tag, int id, const struct _ns1__Revisions *a, const char *type)
02318 {
02319 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__Revisions), type))
02320 return soap->error;
02321 return soap_element_end_out(soap, tag);
02322 }
02323
02324 SOAP_FMAC3 struct _ns1__Revisions * SOAP_FMAC4 soap_get__ns1__Revisions(struct soap *soap, struct _ns1__Revisions *p, const char *tag, const char *type)
02325 {
02326 if ((p = soap_in__ns1__Revisions(soap, tag, p, type)))
02327 if (soap_getindependent(soap))
02328 return NULL;
02329 return p;
02330 }
02331
02332 SOAP_FMAC3 struct _ns1__Revisions * SOAP_FMAC4 soap_in__ns1__Revisions(struct soap *soap, const char *tag, struct _ns1__Revisions *a, const char *type)
02333 {
02334 if (soap_element_begin_in(soap, tag, 0, type))
02335 return NULL;
02336 a = (struct _ns1__Revisions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__Revisions, sizeof(struct _ns1__Revisions), 0, NULL, NULL, NULL);
02337 if (!a)
02338 return NULL;
02339 soap_default__ns1__Revisions(soap, a);
02340 if (soap->body && !*soap->href)
02341 {
02342 for (;;)
02343 { soap->error = SOAP_TAG_MISMATCH;
02344 if (soap->error == SOAP_TAG_MISMATCH)
02345 soap->error = soap_ignore_element(soap);
02346 if (soap->error == SOAP_NO_TAG)
02347 break;
02348 if (soap->error)
02349 return NULL;
02350 }
02351 if (soap_element_end_in(soap, tag))
02352 return NULL;
02353 }
02354 else
02355 { a = (struct _ns1__Revisions *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__Revisions, 0, sizeof(struct _ns1__Revisions), 0, NULL);
02356 if (soap->body && soap_element_end_in(soap, tag))
02357 return NULL;
02358 }
02359 return a;
02360 }
02361
02362 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *a)
02363 {
02364 (void)soap; (void)a;
02365 a->__sizestring = 0;
02366 a->string = NULL;
02367 }
02368
02369 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__ArrayOfString(struct soap *soap, const struct ns1__ArrayOfString *a)
02370 {
02371 (void)soap; (void)a;
02372 if (a->string)
02373 { int i;
02374 for (i = 0; i < a->__sizestring; i++)
02375 {
02376 soap_serialize_string(soap, a->string + i);
02377 }
02378 }
02379 }
02380
02381 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__ArrayOfString(struct soap *soap, const struct ns1__ArrayOfString *a, const char *tag, const char *type)
02382 {
02383 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__ArrayOfString);
02384 if (soap_out_ns1__ArrayOfString(soap, tag, id, a, type))
02385 return soap->error;
02386 return soap_putindependent(soap);
02387 }
02388
02389 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__ArrayOfString(struct soap *soap, const char *tag, int id, const struct ns1__ArrayOfString *a, const char *type)
02390 {
02391 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__ArrayOfString), type))
02392 return soap->error;
02393 if (a->string)
02394 { int i;
02395 for (i = 0; i < a->__sizestring; i++)
02396 if (soap_out_string(soap, "ns1:string", -1, a->string + i, ""))
02397 return soap->error;
02398 }
02399 return soap_element_end_out(soap, tag);
02400 }
02401
02402 SOAP_FMAC3 struct ns1__ArrayOfString * SOAP_FMAC4 soap_get_ns1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *p, const char *tag, const char *type)
02403 {
02404 if ((p = soap_in_ns1__ArrayOfString(soap, tag, p, type)))
02405 if (soap_getindependent(soap))
02406 return NULL;
02407 return p;
02408 }
02409
02410 SOAP_FMAC3 struct ns1__ArrayOfString * SOAP_FMAC4 soap_in_ns1__ArrayOfString(struct soap *soap, const char *tag, struct ns1__ArrayOfString *a, const char *type)
02411 {
02412 short soap_flag_string = 1;
02413 if (soap_element_begin_in(soap, tag, 0, type))
02414 return NULL;
02415 a = (struct ns1__ArrayOfString *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__ArrayOfString, sizeof(struct ns1__ArrayOfString), 0, NULL, NULL, NULL);
02416 if (!a)
02417 return NULL;
02418 soap_default_ns1__ArrayOfString(soap, a);
02419 if (soap->body && !*soap->href)
02420 {
02421 for (;;)
02422 { soap->error = SOAP_TAG_MISMATCH;
02423 if (soap_flag_string && soap->error == SOAP_TAG_MISMATCH)
02424 { char **p;
02425 soap_new_block(soap);
02426 for (a->__sizestring = 0; !soap_element_begin_in(soap, "ns1:string", 1, NULL); a->__sizestring++)
02427 { p = (char **)soap_push_block(soap,NULL, sizeof(char *));
02428 *p = NULL;
02429 soap_revert(soap);
02430 if (!soap_in_string(soap, "ns1:string", p, "xsd:string"))
02431 break;
02432 soap_flag_string = 0;
02433 }
02434 a->string = (char **)soap_save_block(soap, NULL,NULL, 1);
02435 if (!soap_flag_string && soap->error == SOAP_TAG_MISMATCH)
02436 continue;
02437 }
02438 if (soap->error == SOAP_TAG_MISMATCH)
02439 soap->error = soap_ignore_element(soap);
02440 if (soap->error == SOAP_NO_TAG)
02441 break;
02442 if (soap->error)
02443 return NULL;
02444 }
02445 if (soap_element_end_in(soap, tag))
02446 return NULL;
02447 }
02448 else
02449 { a = (struct ns1__ArrayOfString *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__ArrayOfString, 0, sizeof(struct ns1__ArrayOfString), 0, NULL);
02450 if (soap->body && soap_element_end_in(soap, tag))
02451 return NULL;
02452 }
02453 return a;
02454 }
02455
02456 SOAP_FMAC3 void SOAP_FMAC4 soap_default_xsd__base64Binary(struct soap *soap, struct xsd__base64Binary *a)
02457 {
02458 a->__size = 0;
02459 a->__ptr = NULL;
02460 a->id = NULL;
02461 a->type = NULL;
02462 a->options = NULL;
02463 }
02464
02465 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__base64Binary(struct soap *soap, struct xsd__base64Binary const*a)
02466 {
02467 if (a->__ptr && !soap_array_reference(soap, a, (struct soap_array*)&a->__ptr, 1, SOAP_TYPE_xsd__base64Binary))
02468 if (a->id || a->type)
02469 soap->mode |= SOAP_ENC_DIME;
02470 }
02471
02472 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__base64Binary(struct soap *soap, const struct xsd__base64Binary *a, const char *tag, const char *type)
02473 {
02474 register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_xsd__base64Binary);
02475 if (soap_out_xsd__base64Binary(soap, tag, id, a, type))
02476 return soap->error;
02477 return soap_putindependent(soap);
02478 }
02479
02480 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__base64Binary(struct soap *soap, const char *tag, int id, const struct xsd__base64Binary *a, const char *type)
02481 {
02482 #ifndef WITH_LEANER
02483 id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_xsd__base64Binary);
02484 #else
02485 id = soap_element_id(soap, tag, id, a, (struct soap_array*)&a->__ptr, 1, type, SOAP_TYPE_xsd__base64Binary);
02486 #endif
02487 if (id < 0)
02488 return soap->error;
02489 if (soap_element_begin_out(soap, tag, id, type))
02490 return soap->error;
02491 if (soap_putbase64(soap, a->__ptr, a->__size))
02492 return soap->error;
02493 return soap_element_end_out(soap, tag);
02494 }
02495
02496 SOAP_FMAC3 struct xsd__base64Binary * SOAP_FMAC4 soap_get_xsd__base64Binary(struct soap *soap, struct xsd__base64Binary *p, const char *tag, const char *type)
02497 {
02498 if ((p = soap_in_xsd__base64Binary(soap, tag, p, type)))
02499 if (soap_getindependent(soap))
02500 return NULL;
02501 return p;
02502 }
02503
02504 SOAP_FMAC3 struct xsd__base64Binary * SOAP_FMAC4 soap_in_xsd__base64Binary(struct soap *soap, const char *tag, struct xsd__base64Binary *a, const char *type)
02505 {
02506 if (soap_element_begin_in(soap, tag, 1, NULL))
02507 return NULL;
02508 if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64"))
02509 { soap->error = SOAP_TYPE;
02510 return NULL;
02511 }
02512 a = (struct xsd__base64Binary *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_xsd__base64Binary, sizeof(struct xsd__base64Binary), 0, NULL, NULL, NULL);
02513 if (!a)
02514 return NULL;
02515 soap_default_xsd__base64Binary(soap, a);
02516 if (soap->body && !*soap->href)
02517 {
02518 a->__ptr = soap_getbase64(soap, &a->__size, 0);
02519 #ifndef WITH_LEANER
02520 if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options))
02521 return NULL;
02522 #endif
02523 if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag))
02524 return NULL;
02525 }
02526 else
02527 {
02528 #ifndef WITH_LEANER
02529 if (*soap->href != '#')
02530 { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options))
02531 return NULL;
02532 }
02533 else
02534 #endif
02535 a = (struct xsd__base64Binary *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_xsd__base64Binary, 0, sizeof(struct xsd__base64Binary), 0, NULL);
02536 if (soap->body && soap_element_end_in(soap, tag))
02537 return NULL;
02538 }
02539 return a;
02540 }
02541
02542 #ifndef WITH_NOGLOBAL
02543
02544 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
02545 {
02546 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
02547 soap_serialize_SOAP_ENV__Reason(soap, *a);
02548 }
02549
02550 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)
02551 {
02552 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
02553 if (soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, a, type))
02554 return soap->error;
02555 return soap_putindependent(soap);
02556 }
02557
02558 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)
02559 {
02560 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
02561 if (id < 0)
02562 return soap->error;
02563 return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
02564 }
02565
02566 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)
02567 {
02568 if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
02569 if (soap_getindependent(soap))
02570 return NULL;
02571 return p;
02572 }
02573
02574 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)
02575 {
02576 if (soap_element_begin_in(soap, tag, 1, NULL))
02577 return NULL;
02578 if (!a)
02579 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
02580 return NULL;
02581 *a = NULL;
02582 if (!soap->null && *soap->href != '#')
02583 { soap_revert(soap);
02584 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
02585 return NULL;
02586 }
02587 else
02588 { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
02589 if (soap->body && soap_element_end_in(soap, tag))
02590 return NULL;
02591 }
02592 return a;
02593 }
02594
02595 #endif
02596
02597 #ifndef WITH_NOGLOBAL
02598
02599 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
02600 {
02601 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
02602 soap_serialize_SOAP_ENV__Detail(soap, *a);
02603 }
02604
02605 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)
02606 {
02607 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
02608 if (soap_out_PointerToSOAP_ENV__Detail(soap, tag, id, a, type))
02609 return soap->error;
02610 return soap_putindependent(soap);
02611 }
02612
02613 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)
02614 {
02615 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
02616 if (id < 0)
02617 return soap->error;
02618 return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
02619 }
02620
02621 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)
02622 {
02623 if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
02624 if (soap_getindependent(soap))
02625 return NULL;
02626 return p;
02627 }
02628
02629 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)
02630 {
02631 if (soap_element_begin_in(soap, tag, 1, NULL))
02632 return NULL;
02633 if (!a)
02634 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
02635 return NULL;
02636 *a = NULL;
02637 if (!soap->null && *soap->href != '#')
02638 { soap_revert(soap);
02639 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
02640 return NULL;
02641 }
02642 else
02643 { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
02644 if (soap->body && soap_element_end_in(soap, tag))
02645 return NULL;
02646 }
02647 return a;
02648 }
02649
02650 #endif
02651
02652 #ifndef WITH_NOGLOBAL
02653
02654 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
02655 {
02656 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
02657 soap_serialize_SOAP_ENV__Code(soap, *a);
02658 }
02659
02660 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)
02661 {
02662 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
02663 if (soap_out_PointerToSOAP_ENV__Code(soap, tag, id, a, type))
02664 return soap->error;
02665 return soap_putindependent(soap);
02666 }
02667
02668 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)
02669 {
02670 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
02671 if (id < 0)
02672 return soap->error;
02673 return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
02674 }
02675
02676 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)
02677 {
02678 if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
02679 if (soap_getindependent(soap))
02680 return NULL;
02681 return p;
02682 }
02683
02684 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)
02685 {
02686 if (soap_element_begin_in(soap, tag, 1, NULL))
02687 return NULL;
02688 if (!a)
02689 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
02690 return NULL;
02691 *a = NULL;
02692 if (!soap->null && *soap->href != '#')
02693 { soap_revert(soap);
02694 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
02695 return NULL;
02696 }
02697 else
02698 { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
02699 if (soap->body && soap_element_end_in(soap, tag))
02700 return NULL;
02701 }
02702 return a;
02703 }
02704
02705 #endif
02706
02707 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__DimeJpegResponse(struct soap *soap, struct _ns1__DimeJpegResponse *const*a)
02708 {
02709 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__DimeJpegResponse))
02710 soap_serialize__ns1__DimeJpegResponse(soap, *a);
02711 }
02712
02713 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__DimeJpegResponse(struct soap *soap, struct _ns1__DimeJpegResponse *const*a, const char *tag, const char *type)
02714 {
02715 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__DimeJpegResponse);
02716 if (soap_out_PointerTo_ns1__DimeJpegResponse(soap, tag, id, a, type))
02717 return soap->error;
02718 return soap_putindependent(soap);
02719 }
02720
02721 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__DimeJpegResponse(struct soap *soap, const char *tag, int id, struct _ns1__DimeJpegResponse *const*a, const char *type)
02722 {
02723 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__DimeJpegResponse);
02724 if (id < 0)
02725 return soap->error;
02726 return soap_out__ns1__DimeJpegResponse(soap, tag, id, *a, type);
02727 }
02728
02729 SOAP_FMAC3 struct _ns1__DimeJpegResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__DimeJpegResponse(struct soap *soap, struct _ns1__DimeJpegResponse **p, const char *tag, const char *type)
02730 {
02731 if ((p = soap_in_PointerTo_ns1__DimeJpegResponse(soap, tag, p, type)))
02732 if (soap_getindependent(soap))
02733 return NULL;
02734 return p;
02735 }
02736
02737 SOAP_FMAC3 struct _ns1__DimeJpegResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__DimeJpegResponse(struct soap *soap, const char *tag, struct _ns1__DimeJpegResponse **a, const char *type)
02738 {
02739 if (soap_element_begin_in(soap, tag, 1, NULL))
02740 return NULL;
02741 if (!a)
02742 if (!(a = (struct _ns1__DimeJpegResponse **)soap_malloc(soap, sizeof(struct _ns1__DimeJpegResponse *))))
02743 return NULL;
02744 *a = NULL;
02745 if (!soap->null && *soap->href != '#')
02746 { soap_revert(soap);
02747 if (!(*a = soap_in__ns1__DimeJpegResponse(soap, tag, *a, type)))
02748 return NULL;
02749 }
02750 else
02751 { a = (struct _ns1__DimeJpegResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__DimeJpegResponse, sizeof(struct _ns1__DimeJpegResponse), 0);
02752 if (soap->body && soap_element_end_in(soap, tag))
02753 return NULL;
02754 }
02755 return a;
02756 }
02757
02758 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__DimeJpeg(struct soap *soap, struct _ns1__DimeJpeg *const*a)
02759 {
02760 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__DimeJpeg))
02761 soap_serialize__ns1__DimeJpeg(soap, *a);
02762 }
02763
02764 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__DimeJpeg(struct soap *soap, struct _ns1__DimeJpeg *const*a, const char *tag, const char *type)
02765 {
02766 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__DimeJpeg);
02767 if (soap_out_PointerTo_ns1__DimeJpeg(soap, tag, id, a, type))
02768 return soap->error;
02769 return soap_putindependent(soap);
02770 }
02771
02772 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__DimeJpeg(struct soap *soap, const char *tag, int id, struct _ns1__DimeJpeg *const*a, const char *type)
02773 {
02774 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__DimeJpeg);
02775 if (id < 0)
02776 return soap->error;
02777 return soap_out__ns1__DimeJpeg(soap, tag, id, *a, type);
02778 }
02779
02780 SOAP_FMAC3 struct _ns1__DimeJpeg ** SOAP_FMAC4 soap_get_PointerTo_ns1__DimeJpeg(struct soap *soap, struct _ns1__DimeJpeg **p, const char *tag, const char *type)
02781 {
02782 if ((p = soap_in_PointerTo_ns1__DimeJpeg(soap, tag, p, type)))
02783 if (soap_getindependent(soap))
02784 return NULL;
02785 return p;
02786 }
02787
02788 SOAP_FMAC3 struct _ns1__DimeJpeg ** SOAP_FMAC4 soap_in_PointerTo_ns1__DimeJpeg(struct soap *soap, const char *tag, struct _ns1__DimeJpeg **a, const char *type)
02789 {
02790 if (soap_element_begin_in(soap, tag, 1, NULL))
02791 return NULL;
02792 if (!a)
02793 if (!(a = (struct _ns1__DimeJpeg **)soap_malloc(soap, sizeof(struct _ns1__DimeJpeg *))))
02794 return NULL;
02795 *a = NULL;
02796 if (!soap->null && *soap->href != '#')
02797 { soap_revert(soap);
02798 if (!(*a = soap_in__ns1__DimeJpeg(soap, tag, *a, type)))
02799 return NULL;
02800 }
02801 else
02802 { a = (struct _ns1__DimeJpeg **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__DimeJpeg, sizeof(struct _ns1__DimeJpeg), 0);
02803 if (soap->body && soap_element_end_in(soap, tag))
02804 return NULL;
02805 }
02806 return a;
02807 }
02808
02809 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__GetJpegQueryResponse(struct soap *soap, struct _ns1__GetJpegQueryResponse *const*a)
02810 {
02811 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__GetJpegQueryResponse))
02812 soap_serialize__ns1__GetJpegQueryResponse(soap, *a);
02813 }
02814
02815 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__GetJpegQueryResponse(struct soap *soap, struct _ns1__GetJpegQueryResponse *const*a, const char *tag, const char *type)
02816 {
02817 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__GetJpegQueryResponse);
02818 if (soap_out_PointerTo_ns1__GetJpegQueryResponse(soap, tag, id, a, type))
02819 return soap->error;
02820 return soap_putindependent(soap);
02821 }
02822
02823 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__GetJpegQueryResponse(struct soap *soap, const char *tag, int id, struct _ns1__GetJpegQueryResponse *const*a, const char *type)
02824 {
02825 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__GetJpegQueryResponse);
02826 if (id < 0)
02827 return soap->error;
02828 return soap_out__ns1__GetJpegQueryResponse(soap, tag, id, *a, type);
02829 }
02830
02831 SOAP_FMAC3 struct _ns1__GetJpegQueryResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__GetJpegQueryResponse(struct soap *soap, struct _ns1__GetJpegQueryResponse **p, const char *tag, const char *type)
02832 {
02833 if ((p = soap_in_PointerTo_ns1__GetJpegQueryResponse(soap, tag, p, type)))
02834 if (soap_getindependent(soap))
02835 return NULL;
02836 return p;
02837 }
02838
02839 SOAP_FMAC3 struct _ns1__GetJpegQueryResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__GetJpegQueryResponse(struct soap *soap, const char *tag, struct _ns1__GetJpegQueryResponse **a, const char *type)
02840 {
02841 if (soap_element_begin_in(soap, tag, 1, NULL))
02842 return NULL;
02843 if (!a)
02844 if (!(a = (struct _ns1__GetJpegQueryResponse **)soap_malloc(soap, sizeof(struct _ns1__GetJpegQueryResponse *))))
02845 return NULL;
02846 *a = NULL;
02847 if (!soap->null && *soap->href != '#')
02848 { soap_revert(soap);
02849 if (!(*a = soap_in__ns1__GetJpegQueryResponse(soap, tag, *a, type)))
02850 return NULL;
02851 }
02852 else
02853 { a = (struct _ns1__GetJpegQueryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__GetJpegQueryResponse, sizeof(struct _ns1__GetJpegQueryResponse), 0);
02854 if (soap->body && soap_element_end_in(soap, tag))
02855 return NULL;
02856 }
02857 return a;
02858 }
02859
02860 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__GetJpegQuery(struct soap *soap, struct _ns1__GetJpegQuery *const*a)
02861 {
02862 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__GetJpegQuery))
02863 soap_serialize__ns1__GetJpegQuery(soap, *a);
02864 }
02865
02866 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__GetJpegQuery(struct soap *soap, struct _ns1__GetJpegQuery *const*a, const char *tag, const char *type)
02867 {
02868 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__GetJpegQuery);
02869 if (soap_out_PointerTo_ns1__GetJpegQuery(soap, tag, id, a, type))
02870 return soap->error;
02871 return soap_putindependent(soap);
02872 }
02873
02874 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__GetJpegQuery(struct soap *soap, const char *tag, int id, struct _ns1__GetJpegQuery *const*a, const char *type)
02875 {
02876 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__GetJpegQuery);
02877 if (id < 0)
02878 return soap->error;
02879 return soap_out__ns1__GetJpegQuery(soap, tag, id, *a, type);
02880 }
02881
02882 SOAP_FMAC3 struct _ns1__GetJpegQuery ** SOAP_FMAC4 soap_get_PointerTo_ns1__GetJpegQuery(struct soap *soap, struct _ns1__GetJpegQuery **p, const char *tag, const char *type)
02883 {
02884 if ((p = soap_in_PointerTo_ns1__GetJpegQuery(soap, tag, p, type)))
02885 if (soap_getindependent(soap))
02886 return NULL;
02887 return p;
02888 }
02889
02890 SOAP_FMAC3 struct _ns1__GetJpegQuery ** SOAP_FMAC4 soap_in_PointerTo_ns1__GetJpegQuery(struct soap *soap, const char *tag, struct _ns1__GetJpegQuery **a, const char *type)
02891 {
02892 if (soap_element_begin_in(soap, tag, 1, NULL))
02893 return NULL;
02894 if (!a)
02895 if (!(a = (struct _ns1__GetJpegQuery **)soap_malloc(soap, sizeof(struct _ns1__GetJpegQuery *))))
02896 return NULL;
02897 *a = NULL;
02898 if (!soap->null && *soap->href != '#')
02899 { soap_revert(soap);
02900 if (!(*a = soap_in__ns1__GetJpegQuery(soap, tag, *a, type)))
02901 return NULL;
02902 }
02903 else
02904 { a = (struct _ns1__GetJpegQuery **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__GetJpegQuery, sizeof(struct _ns1__GetJpegQuery), 0);
02905 if (soap->body && soap_element_end_in(soap, tag))
02906 return NULL;
02907 }
02908 return a;
02909 }
02910
02911 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__GetJpegResponse(struct soap *soap, struct _ns1__GetJpegResponse *const*a)
02912 {
02913 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__GetJpegResponse))
02914 soap_serialize__ns1__GetJpegResponse(soap, *a);
02915 }
02916
02917 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__GetJpegResponse(struct soap *soap, struct _ns1__GetJpegResponse *const*a, const char *tag, const char *type)
02918 {
02919 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__GetJpegResponse);
02920 if (soap_out_PointerTo_ns1__GetJpegResponse(soap, tag, id, a, type))
02921 return soap->error;
02922 return soap_putindependent(soap);
02923 }
02924
02925 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__GetJpegResponse(struct soap *soap, const char *tag, int id, struct _ns1__GetJpegResponse *const*a, const char *type)
02926 {
02927 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__GetJpegResponse);
02928 if (id < 0)
02929 return soap->error;
02930 return soap_out__ns1__GetJpegResponse(soap, tag, id, *a, type);
02931 }
02932
02933 SOAP_FMAC3 struct _ns1__GetJpegResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__GetJpegResponse(struct soap *soap, struct _ns1__GetJpegResponse **p, const char *tag, const char *type)
02934 {
02935 if ((p = soap_in_PointerTo_ns1__GetJpegResponse(soap, tag, p, type)))
02936 if (soap_getindependent(soap))
02937 return NULL;
02938 return p;
02939 }
02940
02941 SOAP_FMAC3 struct _ns1__GetJpegResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__GetJpegResponse(struct soap *soap, const char *tag, struct _ns1__GetJpegResponse **a, const char *type)
02942 {
02943 if (soap_element_begin_in(soap, tag, 1, NULL))
02944 return NULL;
02945 if (!a)
02946 if (!(a = (struct _ns1__GetJpegResponse **)soap_malloc(soap, sizeof(struct _ns1__GetJpegResponse *))))
02947 return NULL;
02948 *a = NULL;
02949 if (!soap->null && *soap->href != '#')
02950 { soap_revert(soap);
02951 if (!(*a = soap_in__ns1__GetJpegResponse(soap, tag, *a, type)))
02952 return NULL;
02953 }
02954 else
02955 { a = (struct _ns1__GetJpegResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__GetJpegResponse, sizeof(struct _ns1__GetJpegResponse), 0);
02956 if (soap->body && soap_element_end_in(soap, tag))
02957 return NULL;
02958 }
02959 return a;
02960 }
02961
02962 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__GetJpeg(struct soap *soap, struct _ns1__GetJpeg *const*a)
02963 {
02964 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__GetJpeg))
02965 soap_serialize__ns1__GetJpeg(soap, *a);
02966 }
02967
02968 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__GetJpeg(struct soap *soap, struct _ns1__GetJpeg *const*a, const char *tag, const char *type)
02969 {
02970 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__GetJpeg);
02971 if (soap_out_PointerTo_ns1__GetJpeg(soap, tag, id, a, type))
02972 return soap->error;
02973 return soap_putindependent(soap);
02974 }
02975
02976 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__GetJpeg(struct soap *soap, const char *tag, int id, struct _ns1__GetJpeg *const*a, const char *type)
02977 {
02978 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__GetJpeg);
02979 if (id < 0)
02980 return soap->error;
02981 return soap_out__ns1__GetJpeg(soap, tag, id, *a, type);
02982 }
02983
02984 SOAP_FMAC3 struct _ns1__GetJpeg ** SOAP_FMAC4 soap_get_PointerTo_ns1__GetJpeg(struct soap *soap, struct _ns1__GetJpeg **p, const char *tag, const char *type)
02985 {
02986 if ((p = soap_in_PointerTo_ns1__GetJpeg(soap, tag, p, type)))
02987 if (soap_getindependent(soap))
02988 return NULL;
02989 return p;
02990 }
02991
02992 SOAP_FMAC3 struct _ns1__GetJpeg ** SOAP_FMAC4 soap_in_PointerTo_ns1__GetJpeg(struct soap *soap, const char *tag, struct _ns1__GetJpeg **a, const char *type)
02993 {
02994 if (soap_element_begin_in(soap, tag, 1, NULL))
02995 return NULL;
02996 if (!a)
02997 if (!(a = (struct _ns1__GetJpeg **)soap_malloc(soap, sizeof(struct _ns1__GetJpeg *))))
02998 return NULL;
02999 *a = NULL;
03000 if (!soap->null && *soap->href != '#')
03001 { soap_revert(soap);
03002 if (!(*a = soap_in__ns1__GetJpeg(soap, tag, *a, type)))
03003 return NULL;
03004 }
03005 else
03006 { a = (struct _ns1__GetJpeg **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__GetJpeg, sizeof(struct _ns1__GetJpeg), 0);
03007 if (soap->body && soap_element_end_in(soap, tag))
03008 return NULL;
03009 }
03010 return a;
03011 }
03012
03013 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *const*a)
03014 {
03015 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__RevisionsResponse))
03016 soap_serialize__ns1__RevisionsResponse(soap, *a);
03017 }
03018
03019 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *const*a, const char *tag, const char *type)
03020 {
03021 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__RevisionsResponse);
03022 if (soap_out_PointerTo_ns1__RevisionsResponse(soap, tag, id, a, type))
03023 return soap->error;
03024 return soap_putindependent(soap);
03025 }
03026
03027 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__RevisionsResponse(struct soap *soap, const char *tag, int id, struct _ns1__RevisionsResponse *const*a, const char *type)
03028 {
03029 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__RevisionsResponse);
03030 if (id < 0)
03031 return soap->error;
03032 return soap_out__ns1__RevisionsResponse(soap, tag, id, *a, type);
03033 }
03034
03035 SOAP_FMAC3 struct _ns1__RevisionsResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse **p, const char *tag, const char *type)
03036 {
03037 if ((p = soap_in_PointerTo_ns1__RevisionsResponse(soap, tag, p, type)))
03038 if (soap_getindependent(soap))
03039 return NULL;
03040 return p;
03041 }
03042
03043 SOAP_FMAC3 struct _ns1__RevisionsResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__RevisionsResponse(struct soap *soap, const char *tag, struct _ns1__RevisionsResponse **a, const char *type)
03044 {
03045 if (soap_element_begin_in(soap, tag, 1, NULL))
03046 return NULL;
03047 if (!a)
03048 if (!(a = (struct _ns1__RevisionsResponse **)soap_malloc(soap, sizeof(struct _ns1__RevisionsResponse *))))
03049 return NULL;
03050 *a = NULL;
03051 if (!soap->null && *soap->href != '#')
03052 { soap_revert(soap);
03053 if (!(*a = soap_in__ns1__RevisionsResponse(soap, tag, *a, type)))
03054 return NULL;
03055 }
03056 else
03057 { a = (struct _ns1__RevisionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__RevisionsResponse, sizeof(struct _ns1__RevisionsResponse), 0);
03058 if (soap->body && soap_element_end_in(soap, tag))
03059 return NULL;
03060 }
03061 return a;
03062 }
03063
03064 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__Revisions(struct soap *soap, struct _ns1__Revisions *const*a)
03065 {
03066 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__Revisions))
03067 soap_serialize__ns1__Revisions(soap, *a);
03068 }
03069
03070 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__Revisions(struct soap *soap, struct _ns1__Revisions *const*a, const char *tag, const char *type)
03071 {
03072 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__Revisions);
03073 if (soap_out_PointerTo_ns1__Revisions(soap, tag, id, a, type))
03074 return soap->error;
03075 return soap_putindependent(soap);
03076 }
03077
03078 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__Revisions(struct soap *soap, const char *tag, int id, struct _ns1__Revisions *const*a, const char *type)
03079 {
03080 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__Revisions);
03081 if (id < 0)
03082 return soap->error;
03083 return soap_out__ns1__Revisions(soap, tag, id, *a, type);
03084 }
03085
03086 SOAP_FMAC3 struct _ns1__Revisions ** SOAP_FMAC4 soap_get_PointerTo_ns1__Revisions(struct soap *soap, struct _ns1__Revisions **p, const char *tag, const char *type)
03087 {
03088 if ((p = soap_in_PointerTo_ns1__Revisions(soap, tag, p, type)))
03089 if (soap_getindependent(soap))
03090 return NULL;
03091 return p;
03092 }
03093
03094 SOAP_FMAC3 struct _ns1__Revisions ** SOAP_FMAC4 soap_in_PointerTo_ns1__Revisions(struct soap *soap, const char *tag, struct _ns1__Revisions **a, const char *type)
03095 {
03096 if (soap_element_begin_in(soap, tag, 1, NULL))
03097 return NULL;
03098 if (!a)
03099 if (!(a = (struct _ns1__Revisions **)soap_malloc(soap, sizeof(struct _ns1__Revisions *))))
03100 return NULL;
03101 *a = NULL;
03102 if (!soap->null && *soap->href != '#')
03103 { soap_revert(soap);
03104 if (!(*a = soap_in__ns1__Revisions(soap, tag, *a, type)))
03105 return NULL;
03106 }
03107 else
03108 { a = (struct _ns1__Revisions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__Revisions, sizeof(struct _ns1__Revisions), 0);
03109 if (soap->body && soap_element_end_in(soap, tag))
03110 return NULL;
03111 }
03112 return a;
03113 }
03114
03115 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxsd__base64Binary(struct soap *soap, struct xsd__base64Binary *const*a)
03116 {
03117 if (*a)
03118 soap_serialize_xsd__base64Binary(soap, *a);
03119 }
03120
03121 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxsd__base64Binary(struct soap *soap, struct xsd__base64Binary *const*a, const char *tag, const char *type)
03122 {
03123 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxsd__base64Binary);
03124 if (soap_out_PointerToxsd__base64Binary(soap, tag, id, a, type))
03125 return soap->error;
03126 return soap_putindependent(soap);
03127 }
03128
03129 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxsd__base64Binary(struct soap *soap, const char *tag, int id, struct xsd__base64Binary *const*a, const char *type)
03130 {
03131 id = soap_element_id(soap, tag, id, *a, (struct soap_array*)&(*a)->__ptr, 1, type, SOAP_TYPE_xsd__base64Binary);
03132 if (id < 0)
03133 return soap->error;
03134 return soap_out_xsd__base64Binary(soap, tag, id, *a, type);
03135 }
03136
03137 SOAP_FMAC3 struct xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerToxsd__base64Binary(struct soap *soap, struct xsd__base64Binary **p, const char *tag, const char *type)
03138 {
03139 if ((p = soap_in_PointerToxsd__base64Binary(soap, tag, p, type)))
03140 if (soap_getindependent(soap))
03141 return NULL;
03142 return p;
03143 }
03144
03145 SOAP_FMAC3 struct xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerToxsd__base64Binary(struct soap *soap, const char *tag, struct xsd__base64Binary **a, const char *type)
03146 {
03147 if (soap_element_begin_in(soap, tag, 1, NULL))
03148 return NULL;
03149 if (!a)
03150 if (!(a = (struct xsd__base64Binary **)soap_malloc(soap, sizeof(struct xsd__base64Binary *))))
03151 return NULL;
03152 *a = NULL;
03153 if (!soap->null && *soap->href != '#')
03154 { soap_revert(soap);
03155 if (!(*a = soap_in_xsd__base64Binary(soap, tag, *a, type)))
03156 return NULL;
03157 }
03158 else
03159 { a = (struct xsd__base64Binary **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xsd__base64Binary, sizeof(struct xsd__base64Binary), 0);
03160 if (soap->body && soap_element_end_in(soap, tag))
03161 return NULL;
03162 }
03163 return a;
03164 }
03165
03166 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *const*a)
03167 {
03168 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__ArrayOfString))
03169 soap_serialize_ns1__ArrayOfString(soap, *a);
03170 }
03171
03172 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *const*a, const char *tag, const char *type)
03173 {
03174 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__ArrayOfString);
03175 if (soap_out_PointerTons1__ArrayOfString(soap, tag, id, a, type))
03176 return soap->error;
03177 return soap_putindependent(soap);
03178 }
03179
03180 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__ArrayOfString(struct soap *soap, const char *tag, int id, struct ns1__ArrayOfString *const*a, const char *type)
03181 {
03182 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__ArrayOfString);
03183 if (id < 0)
03184 return soap->error;
03185 return soap_out_ns1__ArrayOfString(soap, tag, id, *a, type);
03186 }
03187
03188 SOAP_FMAC3 struct ns1__ArrayOfString ** SOAP_FMAC4 soap_get_PointerTons1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString **p, const char *tag, const char *type)
03189 {
03190 if ((p = soap_in_PointerTons1__ArrayOfString(soap, tag, p, type)))
03191 if (soap_getindependent(soap))
03192 return NULL;
03193 return p;
03194 }
03195
03196 SOAP_FMAC3 struct ns1__ArrayOfString ** SOAP_FMAC4 soap_in_PointerTons1__ArrayOfString(struct soap *soap, const char *tag, struct ns1__ArrayOfString **a, const char *type)
03197 {
03198 if (soap_element_begin_in(soap, tag, 1, NULL))
03199 return NULL;
03200 if (!a)
03201 if (!(a = (struct ns1__ArrayOfString **)soap_malloc(soap, sizeof(struct ns1__ArrayOfString *))))
03202 return NULL;
03203 *a = NULL;
03204 if (!soap->null && *soap->href != '#')
03205 { soap_revert(soap);
03206 if (!(*a = soap_in_ns1__ArrayOfString(soap, tag, *a, type)))
03207 return NULL;
03208 }
03209 else
03210 { a = (struct ns1__ArrayOfString **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__ArrayOfString, sizeof(struct ns1__ArrayOfString), 0);
03211 if (soap->body && soap_element_end_in(soap, tag))
03212 return NULL;
03213 }
03214 return a;
03215 }
03216
03217 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostring(struct soap *soap, char **const*a)
03218 {
03219 if (!soap_reference(soap, *a, SOAP_TYPE_string))
03220 soap_serialize_string(soap, *a);
03221 }
03222
03223 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostring(struct soap *soap, char **const*a, const char *tag, const char *type)
03224 {
03225 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostring);
03226 if (soap_out_PointerTostring(soap, tag, id, a, type))
03227 return soap->error;
03228 return soap_putindependent(soap);
03229 }
03230
03231 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostring(struct soap *soap, const char *tag, int id, char **const*a, const char *type)
03232 {
03233 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_string);
03234 if (id < 0)
03235 return soap->error;
03236 return soap_out_string(soap, tag, id, *a, type);
03237 }
03238
03239 SOAP_FMAC3 char *** SOAP_FMAC4 soap_get_PointerTostring(struct soap *soap, char ***p, const char *tag, const char *type)
03240 {
03241 if ((p = soap_in_PointerTostring(soap, tag, p, type)))
03242 if (soap_getindependent(soap))
03243 return NULL;
03244 return p;
03245 }
03246
03247 SOAP_FMAC3 char *** SOAP_FMAC4 soap_in_PointerTostring(struct soap *soap, const char *tag, char ***a, const char *type)
03248 {
03249 if (soap_element_begin_in(soap, tag, 1, NULL))
03250 return NULL;
03251 if (!a)
03252 if (!(a = (char ***)soap_malloc(soap, sizeof(char **))))
03253 return NULL;
03254 *a = NULL;
03255 if (!soap->null && *soap->href != '#')
03256 { soap_revert(soap);
03257 if (!(*a = soap_in_string(soap, tag, *a, type)))
03258 return NULL;
03259 }
03260 else
03261 { a = (char ***)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_string, sizeof(char *), 1);
03262 if (soap->body && soap_element_end_in(soap, tag))
03263 return NULL;
03264 }
03265 return a;
03266 }
03267
03268 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedByte(struct soap *soap, unsigned char *const*a)
03269 {
03270 soap_reference(soap, *a, SOAP_TYPE_unsignedByte);
03271 }
03272
03273 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedByte(struct soap *soap, unsigned char *const*a, const char *tag, const char *type)
03274 {
03275 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTounsignedByte);
03276 if (soap_out_PointerTounsignedByte(soap, tag, id, a, type))
03277 return soap->error;
03278 return soap_putindependent(soap);
03279 }
03280
03281 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedByte(struct soap *soap, const char *tag, int id, unsigned char *const*a, const char *type)
03282 {
03283 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_unsignedByte);
03284 if (id < 0)
03285 return soap->error;
03286 return soap_out_unsignedByte(soap, tag, id, *a, type);
03287 }
03288
03289 SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_get_PointerTounsignedByte(struct soap *soap, unsigned char **p, const char *tag, const char *type)
03290 {
03291 if ((p = soap_in_PointerTounsignedByte(soap, tag, p, type)))
03292 if (soap_getindependent(soap))
03293 return NULL;
03294 return p;
03295 }
03296
03297 SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_in_PointerTounsignedByte(struct soap *soap, const char *tag, unsigned char **a, const char *type)
03298 {
03299 if (soap_element_begin_in(soap, tag, 1, NULL))
03300 return NULL;
03301 if (!a)
03302 if (!(a = (unsigned char **)soap_malloc(soap, sizeof(unsigned char *))))
03303 return NULL;
03304 *a = NULL;
03305 if (!soap->null && *soap->href != '#')
03306 { soap_revert(soap);
03307 if (!(*a = soap_in_unsignedByte(soap, tag, *a, type)))
03308 return NULL;
03309 }
03310 else
03311 { a = (unsigned char **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_unsignedByte, sizeof(unsigned char), 0);
03312 if (soap->body && soap_element_end_in(soap, tag))
03313 return NULL;
03314 }
03315 return a;
03316 }
03317
03318 SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap *soap, char **a)
03319 { soap_default_string(soap, a);
03320 }
03321
03322 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a)
03323 { soap_serialize_string(soap, a);
03324 }
03325
03326 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
03327 {
03328 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
03329 if (soap_out__QName(soap, tag, id, a, type))
03330 return soap->error;
03331 return soap_putindependent(soap);
03332 }
03333
03334 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
03335 {
03336 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
03337 }
03338
03339 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
03340 {
03341 if ((p = soap_in__QName(soap, tag, p, type)))
03342 if (soap_getindependent(soap))
03343 return NULL;
03344 return p;
03345 }
03346
03347 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
03348 {
03349 return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1);
03350 }
03351
03352 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
03353 { (void)soap;
03354 #ifdef SOAP_DEFAULT_string
03355 *a = SOAP_DEFAULT_string;
03356 #else
03357 *a = (char *)0;
03358 #endif
03359 }
03360
03361 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
03362 {
03363 soap_reference(soap, *a, SOAP_TYPE_string);
03364 }
03365
03366 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
03367 {
03368 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
03369 if (soap_out_string(soap, tag, id, a, type))
03370 return soap->error;
03371 return soap_putindependent(soap);
03372 }
03373
03374 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
03375 {
03376 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
03377 }
03378
03379 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
03380 {
03381 if ((p = soap_in_string(soap, tag, p, type)))
03382 if (soap_getindependent(soap))
03383 return NULL;
03384 return p;
03385 }
03386
03387 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
03388 {
03389 return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1);
03390 }
03391
03392 #ifdef __cplusplus
03393 }
03394 #endif
03395
03396