00001
00002
00003
00004
00005
00006
00007
00008 #include "nedH.h"
00009
00010 #ifdef __cplusplus
00011 extern "C" {
00012 #endif
00013
00014 SOAP_SOURCE_STAMP("@(#) nedC.c ver 2.7.9l 2008-01-25 00:35:12 GMT")
00015
00016
00017 #ifndef WITH_NOGLOBAL
00018
00019 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
00020 {
00021 if (soap->header)
00022 soap_serialize_SOAP_ENV__Header(soap, soap->header);
00023 }
00024
00025 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
00026 {
00027 if (soap->header)
00028 { soap->part = SOAP_IN_HEADER;
00029 if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
00030 return soap->error;
00031 soap->part = SOAP_END_HEADER;
00032 }
00033 return SOAP_OK;
00034 }
00035
00036 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
00037 {
00038 soap->part = SOAP_IN_HEADER;
00039 soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
00040 soap->part = SOAP_END_HEADER;
00041 return soap->header == NULL;
00042 }
00043
00044 SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
00045 {
00046 if (!soap->header)
00047 { soap->header = (struct SOAP_ENV__Header*)soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
00048 soap_default_SOAP_ENV__Header(soap, soap->header);
00049 }
00050 }
00051
00052 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
00053 {
00054 if (!soap->fault)
00055 { soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault));
00056 soap_default_SOAP_ENV__Fault(soap, soap->fault);
00057 }
00058 if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
00059 { soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00060 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
00061 }
00062 if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
00063 { soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason));
00064 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
00065 }
00066 }
00067
00068 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
00069 {
00070 if (soap->fault)
00071 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
00072 }
00073
00074 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
00075 {
00076 if (soap->fault)
00077 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
00078 return SOAP_OK;
00079 }
00080
00081 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
00082 {
00083 return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
00084 }
00085
00086 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
00087 {
00088 soap_fault(soap);
00089 if (soap->version == 2)
00090 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
00091 return (const char**)&soap->fault->faultcode;
00092 }
00093
00094 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
00095 {
00096 soap_fault(soap);
00097 if (soap->version == 2)
00098 { if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
00099 { soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00100 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
00101 }
00102 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
00103 }
00104 return (const char**)&soap->fault->faultcode;
00105 }
00106
00107 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
00108 {
00109 soap_fault(soap);
00110 if (soap->version == 2)
00111 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
00112 return (const char**)&soap->fault->faultstring;
00113 }
00114
00115 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
00116 {
00117 soap_fault(soap);
00118 if (soap->version == 1)
00119 { if (!soap->fault->detail)
00120 { soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00121 soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
00122 }
00123 return (const char**)&soap->fault->detail->__any;
00124 }
00125 if (!soap->fault->SOAP_ENV__Detail)
00126 { soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00127 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
00128 }
00129 return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
00130 }
00131
00132 #endif
00133
00134 #ifndef WITH_NOIDREF
00135 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
00136 {
00137 int t;
00138 for (;;)
00139 if (!soap_getelement(soap, &t))
00140 if (soap->error || soap_ignore_element(soap))
00141 break;
00142 if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
00143 soap->error = SOAP_OK;
00144 return soap->error;
00145 }
00146 #endif
00147
00148 #ifndef WITH_NOIDREF
00149 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
00150 {
00151 if (soap_peek_element(soap))
00152 return NULL;
00153 if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
00154 *type = soap_lookup_type(soap, soap->href);
00155 switch (*type)
00156 {
00157 case SOAP_TYPE_byte:
00158 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
00159 case SOAP_TYPE_int:
00160 return soap_in_int(soap, NULL, NULL, "xsd:int");
00161 case SOAP_TYPE_double:
00162 return soap_in_double(soap, NULL, NULL, "xsd:double");
00163 case SOAP_TYPE_ns1__ArrayOfString:
00164 return soap_in_ns1__ArrayOfString(soap, NULL, NULL, "ns1:ArrayOfString");
00165 case SOAP_TYPE_ns1__ArrayOfObjInfo:
00166 return soap_in_ns1__ArrayOfObjInfo(soap, NULL, NULL, "ns1:ArrayOfObjInfo");
00167 case SOAP_TYPE_ns1__MoreData:
00168 return soap_in_ns1__MoreData(soap, NULL, NULL, "ns1:MoreData");
00169 case SOAP_TYPE_ns1__CrossID:
00170 return soap_in_ns1__CrossID(soap, NULL, NULL, "ns1:CrossID");
00171 case SOAP_TYPE_ns1__ArrayOfMoreData:
00172 return soap_in_ns1__ArrayOfMoreData(soap, NULL, NULL, "ns1:ArrayOfMoreData");
00173 case SOAP_TYPE_ns1__ArrayOfCrossID:
00174 return soap_in_ns1__ArrayOfCrossID(soap, NULL, NULL, "ns1:ArrayOfCrossID");
00175 case SOAP_TYPE_ns1__ObjInfo:
00176 return soap_in_ns1__ObjInfo(soap, NULL, NULL, "ns1:ObjInfo");
00177 case SOAP_TYPE_PointerTo_ns1__RevisionsResponse:
00178 return soap_in_PointerTo_ns1__RevisionsResponse(soap, NULL, NULL, "ns1:RevisionsResponse");
00179 case SOAP_TYPE_PointerTo_ns1__Revisions:
00180 return soap_in_PointerTo_ns1__Revisions(soap, NULL, NULL, "ns1:Revisions");
00181 case SOAP_TYPE_PointerTo_ns1__ObjNearPosnResponse:
00182 return soap_in_PointerTo_ns1__ObjNearPosnResponse(soap, NULL, NULL, "ns1:ObjNearPosnResponse");
00183 case SOAP_TYPE_PointerTo_ns1__ObjNearPosn:
00184 return soap_in_PointerTo_ns1__ObjNearPosn(soap, NULL, NULL, "ns1:ObjNearPosn");
00185 case SOAP_TYPE_PointerTo_ns1__ObjNearNameResponse:
00186 return soap_in_PointerTo_ns1__ObjNearNameResponse(soap, NULL, NULL, "ns1:ObjNearNameResponse");
00187 case SOAP_TYPE_PointerTo_ns1__ObjNearName:
00188 return soap_in_PointerTo_ns1__ObjNearName(soap, NULL, NULL, "ns1:ObjNearName");
00189 case SOAP_TYPE_PointerTo_ns1__ObjByNameResponse:
00190 return soap_in_PointerTo_ns1__ObjByNameResponse(soap, NULL, NULL, "ns1:ObjByNameResponse");
00191 case SOAP_TYPE_PointerTo_ns1__ObjByName:
00192 return soap_in_PointerTo_ns1__ObjByName(soap, NULL, NULL, "ns1:ObjByName");
00193 case SOAP_TYPE_PointerTons1__ArrayOfString:
00194 return soap_in_PointerTons1__ArrayOfString(soap, NULL, NULL, "ns1:ArrayOfString");
00195 case SOAP_TYPE_PointerTons1__ArrayOfObjInfo:
00196 return soap_in_PointerTons1__ArrayOfObjInfo(soap, NULL, NULL, "ns1:ArrayOfObjInfo");
00197 case SOAP_TYPE_PointerTostring:
00198 return soap_in_PointerTostring(soap, NULL, NULL, "xsd:string");
00199 case SOAP_TYPE_PointerTons1__ObjInfo:
00200 return soap_in_PointerTons1__ObjInfo(soap, NULL, NULL, "ns1:ObjInfo");
00201 case SOAP_TYPE_PointerTons1__MoreData:
00202 return soap_in_PointerTons1__MoreData(soap, NULL, NULL, "ns1:MoreData");
00203 case SOAP_TYPE_PointerTons1__CrossID:
00204 return soap_in_PointerTons1__CrossID(soap, NULL, NULL, "ns1:CrossID");
00205 case SOAP_TYPE_PointerTons1__ArrayOfMoreData:
00206 return soap_in_PointerTons1__ArrayOfMoreData(soap, NULL, NULL, "ns1:ArrayOfMoreData");
00207 case SOAP_TYPE_PointerTons1__ArrayOfCrossID:
00208 return soap_in_PointerTons1__ArrayOfCrossID(soap, NULL, NULL, "ns1:ArrayOfCrossID");
00209 case SOAP_TYPE_string:
00210 { char **s;
00211 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00212 return s ? *s : NULL;
00213 }
00214 default:
00215 { const char *t = soap->type;
00216 if (!*t)
00217 t = soap->tag;
00218 if (!soap_match_tag(soap, t, "xsd:byte"))
00219 { *type = SOAP_TYPE_byte;
00220 return soap_in_byte(soap, NULL, NULL, NULL);
00221 }
00222 if (!soap_match_tag(soap, t, "xsd:int"))
00223 { *type = SOAP_TYPE_int;
00224 return soap_in_int(soap, NULL, NULL, NULL);
00225 }
00226 if (!soap_match_tag(soap, t, "xsd:double"))
00227 { *type = SOAP_TYPE_double;
00228 return soap_in_double(soap, NULL, NULL, NULL);
00229 }
00230 if (!soap_match_tag(soap, t, "ns1:ArrayOfString"))
00231 { *type = SOAP_TYPE_ns1__ArrayOfString;
00232 return soap_in_ns1__ArrayOfString(soap, NULL, NULL, NULL);
00233 }
00234 if (!soap_match_tag(soap, t, "ns1:ArrayOfObjInfo"))
00235 { *type = SOAP_TYPE_ns1__ArrayOfObjInfo;
00236 return soap_in_ns1__ArrayOfObjInfo(soap, NULL, NULL, NULL);
00237 }
00238 if (!soap_match_tag(soap, t, "ns1:MoreData"))
00239 { *type = SOAP_TYPE_ns1__MoreData;
00240 return soap_in_ns1__MoreData(soap, NULL, NULL, NULL);
00241 }
00242 if (!soap_match_tag(soap, t, "ns1:CrossID"))
00243 { *type = SOAP_TYPE_ns1__CrossID;
00244 return soap_in_ns1__CrossID(soap, NULL, NULL, NULL);
00245 }
00246 if (!soap_match_tag(soap, t, "ns1:ArrayOfMoreData"))
00247 { *type = SOAP_TYPE_ns1__ArrayOfMoreData;
00248 return soap_in_ns1__ArrayOfMoreData(soap, NULL, NULL, NULL);
00249 }
00250 if (!soap_match_tag(soap, t, "ns1:ArrayOfCrossID"))
00251 { *type = SOAP_TYPE_ns1__ArrayOfCrossID;
00252 return soap_in_ns1__ArrayOfCrossID(soap, NULL, NULL, NULL);
00253 }
00254 if (!soap_match_tag(soap, t, "ns1:ObjInfo"))
00255 { *type = SOAP_TYPE_ns1__ObjInfo;
00256 return soap_in_ns1__ObjInfo(soap, NULL, NULL, NULL);
00257 }
00258 if (!soap_match_tag(soap, t, "xsd:string"))
00259 { char **s;
00260 *type = SOAP_TYPE_string;
00261 s = soap_in_string(soap, NULL, NULL, NULL);
00262 return s ? *s : NULL;
00263 }
00264 t = soap->tag;
00265 if (!soap_match_tag(soap, t, "ns1:RevisionsResponse"))
00266 { *type = SOAP_TYPE__ns1__RevisionsResponse;
00267 return soap_in__ns1__RevisionsResponse(soap, NULL, NULL, NULL);
00268 }
00269 if (!soap_match_tag(soap, t, "ns1:Revisions"))
00270 { *type = SOAP_TYPE__ns1__Revisions;
00271 return soap_in__ns1__Revisions(soap, NULL, NULL, NULL);
00272 }
00273 if (!soap_match_tag(soap, t, "ns1:ObjNearPosnResponse"))
00274 { *type = SOAP_TYPE__ns1__ObjNearPosnResponse;
00275 return soap_in__ns1__ObjNearPosnResponse(soap, NULL, NULL, NULL);
00276 }
00277 if (!soap_match_tag(soap, t, "ns1:ObjNearPosn"))
00278 { *type = SOAP_TYPE__ns1__ObjNearPosn;
00279 return soap_in__ns1__ObjNearPosn(soap, NULL, NULL, NULL);
00280 }
00281 if (!soap_match_tag(soap, t, "ns1:ObjNearNameResponse"))
00282 { *type = SOAP_TYPE__ns1__ObjNearNameResponse;
00283 return soap_in__ns1__ObjNearNameResponse(soap, NULL, NULL, NULL);
00284 }
00285 if (!soap_match_tag(soap, t, "ns1:ObjNearName"))
00286 { *type = SOAP_TYPE__ns1__ObjNearName;
00287 return soap_in__ns1__ObjNearName(soap, NULL, NULL, NULL);
00288 }
00289 if (!soap_match_tag(soap, t, "ns1:ObjByNameResponse"))
00290 { *type = SOAP_TYPE__ns1__ObjByNameResponse;
00291 return soap_in__ns1__ObjByNameResponse(soap, NULL, NULL, NULL);
00292 }
00293 if (!soap_match_tag(soap, t, "ns1:ObjByName"))
00294 { *type = SOAP_TYPE__ns1__ObjByName;
00295 return soap_in__ns1__ObjByName(soap, NULL, NULL, NULL);
00296 }
00297 if (!soap_match_tag(soap, t, "xsd:QName"))
00298 { char **s;
00299 *type = SOAP_TYPE__QName;
00300 s = soap_in__QName(soap, NULL, NULL, NULL);
00301 return s ? *s : NULL;
00302 }
00303 }
00304 }
00305 soap->error = SOAP_TAG_MISMATCH;
00306 return NULL;
00307 }
00308 #endif
00309
00310 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00311 {
00312 if (!soap_peek_element(soap))
00313 { int t;
00314 if (soap->mustUnderstand && !soap->other)
00315 return soap->error = SOAP_MUSTUNDERSTAND;
00316 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00317 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00318 return soap->error = SOAP_TAG_MISMATCH;
00319 }
00320 if (!*soap->id || !soap_getelement(soap, &t))
00321 { soap->peeked = 0;
00322 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00323 if (soap->fignore)
00324 soap->error = soap->fignore(soap, soap->tag);
00325 else
00326 soap->error = SOAP_OK;
00327 DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00328 if (!soap->error && soap->body)
00329 { soap->level++;
00330 while (!soap_ignore_element(soap))
00331 ;
00332 if (soap->error == SOAP_NO_TAG)
00333 soap->error = soap_element_end_in(soap, NULL);
00334 }
00335 }
00336 }
00337 return soap->error;
00338 }
00339
00340 #ifndef WITH_NOIDREF
00341 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00342 {
00343 int i;
00344 struct soap_plist *pp;
00345 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00346 for (i = 0; i < SOAP_PTRHASH; i++)
00347 for (pp = soap->pht[i]; pp; pp = pp->next)
00348 if (pp->mark1 == 2 || pp->mark2 == 2)
00349 if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00350 return soap->error;
00351 return SOAP_OK;
00352 }
00353 #endif
00354
00355 #ifndef WITH_NOIDREF
00356 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00357 {
00358 switch (type)
00359 {
00360 case SOAP_TYPE_byte:
00361 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00362 case SOAP_TYPE_int:
00363 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00364 case SOAP_TYPE_double:
00365 return soap_out_double(soap, tag, id, (const double *)ptr, "xsd:double");
00366 case SOAP_TYPE__ns1__RevisionsResponse:
00367 return soap_out__ns1__RevisionsResponse(soap, "ns1:RevisionsResponse", id, (const struct _ns1__RevisionsResponse *)ptr, NULL);
00368 case SOAP_TYPE__ns1__Revisions:
00369 return soap_out__ns1__Revisions(soap, "ns1:Revisions", id, (const struct _ns1__Revisions *)ptr, NULL);
00370 case SOAP_TYPE__ns1__ObjNearPosnResponse:
00371 return soap_out__ns1__ObjNearPosnResponse(soap, "ns1:ObjNearPosnResponse", id, (const struct _ns1__ObjNearPosnResponse *)ptr, NULL);
00372 case SOAP_TYPE__ns1__ObjNearPosn:
00373 return soap_out__ns1__ObjNearPosn(soap, "ns1:ObjNearPosn", id, (const struct _ns1__ObjNearPosn *)ptr, NULL);
00374 case SOAP_TYPE__ns1__ObjNearNameResponse:
00375 return soap_out__ns1__ObjNearNameResponse(soap, "ns1:ObjNearNameResponse", id, (const struct _ns1__ObjNearNameResponse *)ptr, NULL);
00376 case SOAP_TYPE__ns1__ObjNearName:
00377 return soap_out__ns1__ObjNearName(soap, "ns1:ObjNearName", id, (const struct _ns1__ObjNearName *)ptr, NULL);
00378 case SOAP_TYPE__ns1__ObjByNameResponse:
00379 return soap_out__ns1__ObjByNameResponse(soap, "ns1:ObjByNameResponse", id, (const struct _ns1__ObjByNameResponse *)ptr, NULL);
00380 case SOAP_TYPE__ns1__ObjByName:
00381 return soap_out__ns1__ObjByName(soap, "ns1:ObjByName", id, (const struct _ns1__ObjByName *)ptr, NULL);
00382 case SOAP_TYPE_ns1__ArrayOfString:
00383 return soap_out_ns1__ArrayOfString(soap, tag, id, (const struct ns1__ArrayOfString *)ptr, "ns1:ArrayOfString");
00384 case SOAP_TYPE_ns1__ArrayOfObjInfo:
00385 return soap_out_ns1__ArrayOfObjInfo(soap, tag, id, (const struct ns1__ArrayOfObjInfo *)ptr, "ns1:ArrayOfObjInfo");
00386 case SOAP_TYPE_ns1__MoreData:
00387 return soap_out_ns1__MoreData(soap, tag, id, (const struct ns1__MoreData *)ptr, "ns1:MoreData");
00388 case SOAP_TYPE_ns1__CrossID:
00389 return soap_out_ns1__CrossID(soap, tag, id, (const struct ns1__CrossID *)ptr, "ns1:CrossID");
00390 case SOAP_TYPE_ns1__ArrayOfMoreData:
00391 return soap_out_ns1__ArrayOfMoreData(soap, tag, id, (const struct ns1__ArrayOfMoreData *)ptr, "ns1:ArrayOfMoreData");
00392 case SOAP_TYPE_ns1__ArrayOfCrossID:
00393 return soap_out_ns1__ArrayOfCrossID(soap, tag, id, (const struct ns1__ArrayOfCrossID *)ptr, "ns1:ArrayOfCrossID");
00394 case SOAP_TYPE_ns1__ObjInfo:
00395 return soap_out_ns1__ObjInfo(soap, tag, id, (const struct ns1__ObjInfo *)ptr, "ns1:ObjInfo");
00396 case SOAP_TYPE_PointerTo_ns1__RevisionsResponse:
00397 return soap_out_PointerTo_ns1__RevisionsResponse(soap, tag, id, (struct _ns1__RevisionsResponse *const*)ptr, "ns1:RevisionsResponse");
00398 case SOAP_TYPE_PointerTo_ns1__Revisions:
00399 return soap_out_PointerTo_ns1__Revisions(soap, tag, id, (struct _ns1__Revisions *const*)ptr, "ns1:Revisions");
00400 case SOAP_TYPE_PointerTo_ns1__ObjNearPosnResponse:
00401 return soap_out_PointerTo_ns1__ObjNearPosnResponse(soap, tag, id, (struct _ns1__ObjNearPosnResponse *const*)ptr, "ns1:ObjNearPosnResponse");
00402 case SOAP_TYPE_PointerTo_ns1__ObjNearPosn:
00403 return soap_out_PointerTo_ns1__ObjNearPosn(soap, tag, id, (struct _ns1__ObjNearPosn *const*)ptr, "ns1:ObjNearPosn");
00404 case SOAP_TYPE_PointerTo_ns1__ObjNearNameResponse:
00405 return soap_out_PointerTo_ns1__ObjNearNameResponse(soap, tag, id, (struct _ns1__ObjNearNameResponse *const*)ptr, "ns1:ObjNearNameResponse");
00406 case SOAP_TYPE_PointerTo_ns1__ObjNearName:
00407 return soap_out_PointerTo_ns1__ObjNearName(soap, tag, id, (struct _ns1__ObjNearName *const*)ptr, "ns1:ObjNearName");
00408 case SOAP_TYPE_PointerTo_ns1__ObjByNameResponse:
00409 return soap_out_PointerTo_ns1__ObjByNameResponse(soap, tag, id, (struct _ns1__ObjByNameResponse *const*)ptr, "ns1:ObjByNameResponse");
00410 case SOAP_TYPE_PointerTo_ns1__ObjByName:
00411 return soap_out_PointerTo_ns1__ObjByName(soap, tag, id, (struct _ns1__ObjByName *const*)ptr, "ns1:ObjByName");
00412 case SOAP_TYPE_PointerTons1__ArrayOfString:
00413 return soap_out_PointerTons1__ArrayOfString(soap, tag, id, (struct ns1__ArrayOfString *const*)ptr, "ns1:ArrayOfString");
00414 case SOAP_TYPE_PointerTons1__ArrayOfObjInfo:
00415 return soap_out_PointerTons1__ArrayOfObjInfo(soap, tag, id, (struct ns1__ArrayOfObjInfo *const*)ptr, "ns1:ArrayOfObjInfo");
00416 case SOAP_TYPE_PointerTostring:
00417 return soap_out_PointerTostring(soap, tag, id, (char **const*)ptr, "xsd:string");
00418 case SOAP_TYPE_PointerTons1__ObjInfo:
00419 return soap_out_PointerTons1__ObjInfo(soap, tag, id, (struct ns1__ObjInfo *const*)ptr, "ns1:ObjInfo");
00420 case SOAP_TYPE_PointerTons1__MoreData:
00421 return soap_out_PointerTons1__MoreData(soap, tag, id, (struct ns1__MoreData *const*)ptr, "ns1:MoreData");
00422 case SOAP_TYPE_PointerTons1__CrossID:
00423 return soap_out_PointerTons1__CrossID(soap, tag, id, (struct ns1__CrossID *const*)ptr, "ns1:CrossID");
00424 case SOAP_TYPE_PointerTons1__ArrayOfMoreData:
00425 return soap_out_PointerTons1__ArrayOfMoreData(soap, tag, id, (struct ns1__ArrayOfMoreData *const*)ptr, "ns1:ArrayOfMoreData");
00426 case SOAP_TYPE_PointerTons1__ArrayOfCrossID:
00427 return soap_out_PointerTons1__ArrayOfCrossID(soap, tag, id, (struct ns1__ArrayOfCrossID *const*)ptr, "ns1:ArrayOfCrossID");
00428 case SOAP_TYPE__QName:
00429 return soap_out_string(soap, "xsd:QName", id, (char*const*)&ptr, NULL);
00430 case SOAP_TYPE_string:
00431 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
00432 }
00433 return SOAP_OK;
00434 }
00435 #endif
00436
00437 #ifndef WITH_NOIDREF
00438 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00439 {
00440 (void)soap; (void)ptr; (void)type;
00441 switch (type)
00442 {
00443 case SOAP_TYPE___ns3__Revisions:
00444 soap_serialize___ns3__Revisions(soap, (const struct __ns3__Revisions *)ptr);
00445 break;
00446 case SOAP_TYPE___ns3__ObjNearPosn:
00447 soap_serialize___ns3__ObjNearPosn(soap, (const struct __ns3__ObjNearPosn *)ptr);
00448 break;
00449 case SOAP_TYPE___ns3__ObjNearName:
00450 soap_serialize___ns3__ObjNearName(soap, (const struct __ns3__ObjNearName *)ptr);
00451 break;
00452 case SOAP_TYPE___ns3__ObjByName:
00453 soap_serialize___ns3__ObjByName(soap, (const struct __ns3__ObjByName *)ptr);
00454 break;
00455 case SOAP_TYPE___ns2__Revisions:
00456 soap_serialize___ns2__Revisions(soap, (const struct __ns2__Revisions *)ptr);
00457 break;
00458 case SOAP_TYPE___ns2__ObjNearPosn:
00459 soap_serialize___ns2__ObjNearPosn(soap, (const struct __ns2__ObjNearPosn *)ptr);
00460 break;
00461 case SOAP_TYPE___ns2__ObjNearName:
00462 soap_serialize___ns2__ObjNearName(soap, (const struct __ns2__ObjNearName *)ptr);
00463 break;
00464 case SOAP_TYPE___ns2__ObjByName:
00465 soap_serialize___ns2__ObjByName(soap, (const struct __ns2__ObjByName *)ptr);
00466 break;
00467 case SOAP_TYPE__ns1__RevisionsResponse:
00468 soap_serialize__ns1__RevisionsResponse(soap, (const struct _ns1__RevisionsResponse *)ptr);
00469 break;
00470 case SOAP_TYPE__ns1__Revisions:
00471 soap_serialize__ns1__Revisions(soap, (const struct _ns1__Revisions *)ptr);
00472 break;
00473 case SOAP_TYPE__ns1__ObjNearPosnResponse:
00474 soap_serialize__ns1__ObjNearPosnResponse(soap, (const struct _ns1__ObjNearPosnResponse *)ptr);
00475 break;
00476 case SOAP_TYPE__ns1__ObjNearPosn:
00477 soap_serialize__ns1__ObjNearPosn(soap, (const struct _ns1__ObjNearPosn *)ptr);
00478 break;
00479 case SOAP_TYPE__ns1__ObjNearNameResponse:
00480 soap_serialize__ns1__ObjNearNameResponse(soap, (const struct _ns1__ObjNearNameResponse *)ptr);
00481 break;
00482 case SOAP_TYPE__ns1__ObjNearName:
00483 soap_serialize__ns1__ObjNearName(soap, (const struct _ns1__ObjNearName *)ptr);
00484 break;
00485 case SOAP_TYPE__ns1__ObjByNameResponse:
00486 soap_serialize__ns1__ObjByNameResponse(soap, (const struct _ns1__ObjByNameResponse *)ptr);
00487 break;
00488 case SOAP_TYPE__ns1__ObjByName:
00489 soap_serialize__ns1__ObjByName(soap, (const struct _ns1__ObjByName *)ptr);
00490 break;
00491 case SOAP_TYPE_ns1__ArrayOfString:
00492 soap_serialize_ns1__ArrayOfString(soap, (const struct ns1__ArrayOfString *)ptr);
00493 break;
00494 case SOAP_TYPE_ns1__ArrayOfObjInfo:
00495 soap_serialize_ns1__ArrayOfObjInfo(soap, (const struct ns1__ArrayOfObjInfo *)ptr);
00496 break;
00497 case SOAP_TYPE_ns1__MoreData:
00498 soap_serialize_ns1__MoreData(soap, (const struct ns1__MoreData *)ptr);
00499 break;
00500 case SOAP_TYPE_ns1__CrossID:
00501 soap_serialize_ns1__CrossID(soap, (const struct ns1__CrossID *)ptr);
00502 break;
00503 case SOAP_TYPE_ns1__ArrayOfMoreData:
00504 soap_serialize_ns1__ArrayOfMoreData(soap, (const struct ns1__ArrayOfMoreData *)ptr);
00505 break;
00506 case SOAP_TYPE_ns1__ArrayOfCrossID:
00507 soap_serialize_ns1__ArrayOfCrossID(soap, (const struct ns1__ArrayOfCrossID *)ptr);
00508 break;
00509 case SOAP_TYPE_ns1__ObjInfo:
00510 soap_serialize_ns1__ObjInfo(soap, (const struct ns1__ObjInfo *)ptr);
00511 break;
00512 case SOAP_TYPE_PointerTo_ns1__RevisionsResponse:
00513 soap_serialize_PointerTo_ns1__RevisionsResponse(soap, (struct _ns1__RevisionsResponse *const*)ptr);
00514 break;
00515 case SOAP_TYPE_PointerTo_ns1__Revisions:
00516 soap_serialize_PointerTo_ns1__Revisions(soap, (struct _ns1__Revisions *const*)ptr);
00517 break;
00518 case SOAP_TYPE_PointerTo_ns1__ObjNearPosnResponse:
00519 soap_serialize_PointerTo_ns1__ObjNearPosnResponse(soap, (struct _ns1__ObjNearPosnResponse *const*)ptr);
00520 break;
00521 case SOAP_TYPE_PointerTo_ns1__ObjNearPosn:
00522 soap_serialize_PointerTo_ns1__ObjNearPosn(soap, (struct _ns1__ObjNearPosn *const*)ptr);
00523 break;
00524 case SOAP_TYPE_PointerTo_ns1__ObjNearNameResponse:
00525 soap_serialize_PointerTo_ns1__ObjNearNameResponse(soap, (struct _ns1__ObjNearNameResponse *const*)ptr);
00526 break;
00527 case SOAP_TYPE_PointerTo_ns1__ObjNearName:
00528 soap_serialize_PointerTo_ns1__ObjNearName(soap, (struct _ns1__ObjNearName *const*)ptr);
00529 break;
00530 case SOAP_TYPE_PointerTo_ns1__ObjByNameResponse:
00531 soap_serialize_PointerTo_ns1__ObjByNameResponse(soap, (struct _ns1__ObjByNameResponse *const*)ptr);
00532 break;
00533 case SOAP_TYPE_PointerTo_ns1__ObjByName:
00534 soap_serialize_PointerTo_ns1__ObjByName(soap, (struct _ns1__ObjByName *const*)ptr);
00535 break;
00536 case SOAP_TYPE_PointerTons1__ArrayOfString:
00537 soap_serialize_PointerTons1__ArrayOfString(soap, (struct ns1__ArrayOfString *const*)ptr);
00538 break;
00539 case SOAP_TYPE_PointerTons1__ArrayOfObjInfo:
00540 soap_serialize_PointerTons1__ArrayOfObjInfo(soap, (struct ns1__ArrayOfObjInfo *const*)ptr);
00541 break;
00542 case SOAP_TYPE_PointerTostring:
00543 soap_serialize_PointerTostring(soap, (char **const*)ptr);
00544 break;
00545 case SOAP_TYPE_PointerTons1__ObjInfo:
00546 soap_serialize_PointerTons1__ObjInfo(soap, (struct ns1__ObjInfo *const*)ptr);
00547 break;
00548 case SOAP_TYPE_PointerTons1__MoreData:
00549 soap_serialize_PointerTons1__MoreData(soap, (struct ns1__MoreData *const*)ptr);
00550 break;
00551 case SOAP_TYPE_PointerTons1__CrossID:
00552 soap_serialize_PointerTons1__CrossID(soap, (struct ns1__CrossID *const*)ptr);
00553 break;
00554 case SOAP_TYPE_PointerTons1__ArrayOfMoreData:
00555 soap_serialize_PointerTons1__ArrayOfMoreData(soap, (struct ns1__ArrayOfMoreData *const*)ptr);
00556 break;
00557 case SOAP_TYPE_PointerTons1__ArrayOfCrossID:
00558 soap_serialize_PointerTons1__ArrayOfCrossID(soap, (struct ns1__ArrayOfCrossID *const*)ptr);
00559 break;
00560 case SOAP_TYPE__QName:
00561 soap_serialize_string(soap, (char*const*)&ptr);
00562 break;
00563 case SOAP_TYPE_string:
00564 soap_serialize_string(soap, (char*const*)&ptr);
00565 break;
00566 }
00567 }
00568 #endif
00569
00570 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00571 { (void)soap;
00572 #ifdef SOAP_DEFAULT_byte
00573 *a = SOAP_DEFAULT_byte;
00574 #else
00575 *a = (char)0;
00576 #endif
00577 }
00578
00579 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00580 {
00581 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00582 if (soap_out_byte(soap, tag, id, a, type))
00583 return soap->error;
00584 return soap_putindependent(soap);
00585 }
00586
00587 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00588 {
00589 return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00590 }
00591
00592 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00593 {
00594 if ((p = soap_in_byte(soap, tag, p, type)))
00595 if (soap_getindependent(soap))
00596 return NULL;
00597 return p;
00598 }
00599
00600 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00601 {
00602 return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00603 }
00604
00605 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00606 { (void)soap;
00607 #ifdef SOAP_DEFAULT_int
00608 *a = SOAP_DEFAULT_int;
00609 #else
00610 *a = (int)0;
00611 #endif
00612 }
00613
00614 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00615 {
00616 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00617 if (soap_out_int(soap, tag, id, a, type))
00618 return soap->error;
00619 return soap_putindependent(soap);
00620 }
00621
00622 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
00623 {
00624 return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
00625 }
00626
00627 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00628 {
00629 if ((p = soap_in_int(soap, tag, p, type)))
00630 if (soap_getindependent(soap))
00631 return NULL;
00632 return p;
00633 }
00634
00635 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00636 {
00637 return soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00638 }
00639
00640 SOAP_FMAC3 void SOAP_FMAC4 soap_default_double(struct soap *soap, double *a)
00641 { (void)soap;
00642 #ifdef SOAP_DEFAULT_double
00643 *a = SOAP_DEFAULT_double;
00644 #else
00645 *a = (double)0;
00646 #endif
00647 }
00648
00649 SOAP_FMAC3 int SOAP_FMAC4 soap_put_double(struct soap *soap, const double *a, const char *tag, const char *type)
00650 {
00651 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_double);
00652 if (soap_out_double(soap, tag, id, a, type))
00653 return soap->error;
00654 return soap_putindependent(soap);
00655 }
00656
00657 SOAP_FMAC3 int SOAP_FMAC4 soap_out_double(struct soap *soap, const char *tag, int id, const double *a, const char *type)
00658 {
00659 return soap_outdouble(soap, tag, id, a, type, SOAP_TYPE_double);
00660 }
00661
00662 SOAP_FMAC3 double * SOAP_FMAC4 soap_get_double(struct soap *soap, double *p, const char *tag, const char *type)
00663 {
00664 if ((p = soap_in_double(soap, tag, p, type)))
00665 if (soap_getindependent(soap))
00666 return NULL;
00667 return p;
00668 }
00669
00670 SOAP_FMAC3 double * SOAP_FMAC4 soap_in_double(struct soap *soap, const char *tag, double *a, const char *type)
00671 {
00672 return soap_indouble(soap, tag, a, type, SOAP_TYPE_double);
00673 }
00674
00675 #ifndef WITH_NOGLOBAL
00676
00677 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
00678 {
00679 (void)soap; (void)a;
00680 soap_default__QName(soap, &a->faultcode);
00681 soap_default_string(soap, &a->faultstring);
00682 soap_default_string(soap, &a->faultactor);
00683 a->detail = NULL;
00684 a->SOAP_ENV__Code = NULL;
00685 a->SOAP_ENV__Reason = NULL;
00686 soap_default_string(soap, &a->SOAP_ENV__Node);
00687 soap_default_string(soap, &a->SOAP_ENV__Role);
00688 a->SOAP_ENV__Detail = NULL;
00689 }
00690
00691 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
00692 {
00693 (void)soap; (void)a;
00694 soap_serialize__QName(soap, &a->faultcode);
00695 soap_serialize_string(soap, &a->faultstring);
00696 soap_serialize_string(soap, &a->faultactor);
00697 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
00698 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
00699 soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
00700 soap_serialize_string(soap, &a->SOAP_ENV__Node);
00701 soap_serialize_string(soap, &a->SOAP_ENV__Role);
00702 soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
00703 }
00704
00705 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)
00706 {
00707 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
00708 if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type))
00709 return soap->error;
00710 return soap_putindependent(soap);
00711 }
00712
00713 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)
00714 {
00715 const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
00716 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
00717 return soap->error;
00718 if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
00719 return soap->error;
00720 if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
00721 return soap->error;
00722 if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
00723 return soap->error;
00724 if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
00725 return soap->error;
00726 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
00727 return soap->error;
00728 if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
00729 return soap->error;
00730 if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
00731 return soap->error;
00732 if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
00733 return soap->error;
00734 if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
00735 return soap->error;
00736 return soap_element_end_out(soap, tag);
00737 }
00738
00739 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)
00740 {
00741 if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
00742 if (soap_getindependent(soap))
00743 return NULL;
00744 return p;
00745 }
00746
00747 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)
00748 {
00749 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;
00750 if (soap_element_begin_in(soap, tag, 0, type))
00751 return NULL;
00752 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);
00753 if (!a)
00754 return NULL;
00755 soap_default_SOAP_ENV__Fault(soap, a);
00756 if (soap->body && !*soap->href)
00757 {
00758 for (;;)
00759 { soap->error = SOAP_TAG_MISMATCH;
00760 if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00761 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
00762 { soap_flag_faultcode--;
00763 continue;
00764 }
00765 if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00766 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
00767 { soap_flag_faultstring--;
00768 continue;
00769 }
00770 if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00771 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
00772 { soap_flag_faultactor--;
00773 continue;
00774 }
00775 if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
00776 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
00777 { soap_flag_detail--;
00778 continue;
00779 }
00780 if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
00781 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
00782 { soap_flag_SOAP_ENV__Code--;
00783 continue;
00784 }
00785 if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
00786 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
00787 { soap_flag_SOAP_ENV__Reason--;
00788 continue;
00789 }
00790 if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00791 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
00792 { soap_flag_SOAP_ENV__Node--;
00793 continue;
00794 }
00795 if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00796 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
00797 { soap_flag_SOAP_ENV__Role--;
00798 continue;
00799 }
00800 if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
00801 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
00802 { soap_flag_SOAP_ENV__Detail--;
00803 continue;
00804 }
00805 if (soap->error == SOAP_TAG_MISMATCH)
00806 soap->error = soap_ignore_element(soap);
00807 if (soap->error == SOAP_NO_TAG)
00808 break;
00809 if (soap->error)
00810 return NULL;
00811 }
00812 if (soap_element_end_in(soap, tag))
00813 return NULL;
00814 }
00815 else
00816 { 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);
00817 if (soap->body && soap_element_end_in(soap, tag))
00818 return NULL;
00819 }
00820 return a;
00821 }
00822
00823 #endif
00824
00825 #ifndef WITH_NOGLOBAL
00826
00827 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
00828 {
00829 (void)soap; (void)a;
00830 soap_default_string(soap, &a->SOAP_ENV__Text);
00831 }
00832
00833 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
00834 {
00835 (void)soap; (void)a;
00836 soap_serialize_string(soap, &a->SOAP_ENV__Text);
00837 }
00838
00839 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)
00840 {
00841 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
00842 if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type))
00843 return soap->error;
00844 return soap_putindependent(soap);
00845 }
00846
00847 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)
00848 {
00849 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
00850 return soap->error;
00851 if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
00852 return soap->error;
00853 return soap_element_end_out(soap, tag);
00854 }
00855
00856 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)
00857 {
00858 if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
00859 if (soap_getindependent(soap))
00860 return NULL;
00861 return p;
00862 }
00863
00864 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)
00865 {
00866 short soap_flag_SOAP_ENV__Text = 1;
00867 if (soap_element_begin_in(soap, tag, 0, type))
00868 return NULL;
00869 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);
00870 if (!a)
00871 return NULL;
00872 soap_default_SOAP_ENV__Reason(soap, a);
00873 if (soap->body && !*soap->href)
00874 {
00875 for (;;)
00876 { soap->error = SOAP_TAG_MISMATCH;
00877 if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00878 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
00879 { soap_flag_SOAP_ENV__Text--;
00880 continue;
00881 }
00882 if (soap->error == SOAP_TAG_MISMATCH)
00883 soap->error = soap_ignore_element(soap);
00884 if (soap->error == SOAP_NO_TAG)
00885 break;
00886 if (soap->error)
00887 return NULL;
00888 }
00889 if (soap_element_end_in(soap, tag))
00890 return NULL;
00891 }
00892 else
00893 { 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);
00894 if (soap->body && soap_element_end_in(soap, tag))
00895 return NULL;
00896 }
00897 return a;
00898 }
00899
00900 #endif
00901
00902 #ifndef WITH_NOGLOBAL
00903
00904 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
00905 {
00906 (void)soap; (void)a;
00907 a->__type = 0;
00908 a->fault = NULL;
00909 a->__any = NULL;
00910 }
00911
00912 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
00913 {
00914 (void)soap; (void)a;
00915 soap_markelement(soap, a->fault, a->__type);
00916 }
00917
00918 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)
00919 {
00920 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
00921 if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type))
00922 return soap->error;
00923 return soap_putindependent(soap);
00924 }
00925
00926 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)
00927 {
00928 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
00929 return soap->error;
00930 if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
00931 return soap->error;
00932 soap_outliteral(soap, "-any", &a->__any, NULL);
00933 return soap_element_end_out(soap, tag);
00934 }
00935
00936 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)
00937 {
00938 if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
00939 if (soap_getindependent(soap))
00940 return NULL;
00941 return p;
00942 }
00943
00944 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)
00945 {
00946 short soap_flag_fault = 1, soap_flag___any = 1;
00947 if (soap_element_begin_in(soap, tag, 0, type))
00948 return NULL;
00949 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);
00950 if (!a)
00951 return NULL;
00952 soap_default_SOAP_ENV__Detail(soap, a);
00953 if (soap->body && !*soap->href)
00954 {
00955 for (;;)
00956 { soap->error = SOAP_TAG_MISMATCH;
00957 if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
00958 if ((a->fault = soap_getelement(soap, &a->__type)))
00959 { soap_flag_fault = 0;
00960 continue;
00961 }
00962 if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
00963 if (soap_inliteral(soap, "-any", &a->__any))
00964 { soap_flag___any--;
00965 continue;
00966 }
00967 if (soap->error == SOAP_TAG_MISMATCH)
00968 soap->error = soap_ignore_element(soap);
00969 if (soap->error == SOAP_NO_TAG)
00970 break;
00971 if (soap->error)
00972 return NULL;
00973 }
00974 if (soap_element_end_in(soap, tag))
00975 return NULL;
00976 }
00977 else
00978 { 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);
00979 if (soap->body && soap_element_end_in(soap, tag))
00980 return NULL;
00981 }
00982 return a;
00983 }
00984
00985 #endif
00986
00987 #ifndef WITH_NOGLOBAL
00988
00989 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
00990 {
00991 (void)soap; (void)a;
00992 soap_default__QName(soap, &a->SOAP_ENV__Value);
00993 a->SOAP_ENV__Subcode = NULL;
00994 }
00995
00996 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
00997 {
00998 (void)soap; (void)a;
00999 soap_serialize__QName(soap, &a->SOAP_ENV__Value);
01000 soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
01001 }
01002
01003 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)
01004 {
01005 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
01006 if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type))
01007 return soap->error;
01008 return soap_putindependent(soap);
01009 }
01010
01011 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)
01012 {
01013 const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
01014 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
01015 return soap->error;
01016 if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
01017 return soap->error;
01018 if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
01019 return soap->error;
01020 return soap_element_end_out(soap, tag);
01021 }
01022
01023 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)
01024 {
01025 if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
01026 if (soap_getindependent(soap))
01027 return NULL;
01028 return p;
01029 }
01030
01031 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)
01032 {
01033 short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1;
01034 if (soap_element_begin_in(soap, tag, 0, type))
01035 return NULL;
01036 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);
01037 if (!a)
01038 return NULL;
01039 soap_default_SOAP_ENV__Code(soap, a);
01040 if (soap->body && !*soap->href)
01041 {
01042 for (;;)
01043 { soap->error = SOAP_TAG_MISMATCH;
01044 if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01045 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
01046 { soap_flag_SOAP_ENV__Value--;
01047 continue;
01048 }
01049 if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
01050 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
01051 { soap_flag_SOAP_ENV__Subcode--;
01052 continue;
01053 }
01054 if (soap->error == SOAP_TAG_MISMATCH)
01055 soap->error = soap_ignore_element(soap);
01056 if (soap->error == SOAP_NO_TAG)
01057 break;
01058 if (soap->error)
01059 return NULL;
01060 }
01061 if (soap_element_end_in(soap, tag))
01062 return NULL;
01063 }
01064 else
01065 { 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);
01066 if (soap->body && soap_element_end_in(soap, tag))
01067 return NULL;
01068 }
01069 return a;
01070 }
01071
01072 #endif
01073
01074 #ifndef WITH_NOGLOBAL
01075
01076 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
01077 {
01078 (void)soap; (void)a;
01079 }
01080
01081 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
01082 {
01083 (void)soap; (void)a;
01084 }
01085
01086 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)
01087 {
01088 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
01089 if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type))
01090 return soap->error;
01091 return soap_putindependent(soap);
01092 }
01093
01094 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)
01095 {
01096 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
01097 return soap->error;
01098 return soap_element_end_out(soap, tag);
01099 }
01100
01101 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)
01102 {
01103 if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
01104 if (soap_getindependent(soap))
01105 return NULL;
01106 return p;
01107 }
01108
01109 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)
01110 {
01111 if (soap_element_begin_in(soap, tag, 0, type))
01112 return NULL;
01113 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);
01114 if (!a)
01115 return NULL;
01116 soap_default_SOAP_ENV__Header(soap, a);
01117 if (soap->body && !*soap->href)
01118 {
01119 for (;;)
01120 { soap->error = SOAP_TAG_MISMATCH;
01121 if (soap->error == SOAP_TAG_MISMATCH)
01122 soap->error = soap_ignore_element(soap);
01123 if (soap->error == SOAP_NO_TAG)
01124 break;
01125 if (soap->error)
01126 return NULL;
01127 }
01128 if (soap_element_end_in(soap, tag))
01129 return NULL;
01130 }
01131 else
01132 { 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);
01133 if (soap->body && soap_element_end_in(soap, tag))
01134 return NULL;
01135 }
01136 return a;
01137 }
01138
01139 #endif
01140
01141 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__Revisions(struct soap *soap, struct __ns3__Revisions *a)
01142 {
01143 (void)soap; (void)a;
01144 a->ns1__Revisions = NULL;
01145 }
01146
01147 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__Revisions(struct soap *soap, const struct __ns3__Revisions *a)
01148 {
01149 (void)soap; (void)a;
01150 soap_serialize_PointerTo_ns1__Revisions(soap, &a->ns1__Revisions);
01151 }
01152
01153 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__Revisions(struct soap *soap, const struct __ns3__Revisions *a, const char *tag, const char *type)
01154 {
01155 register int id = 0;
01156 if (soap_out___ns3__Revisions(soap, tag, id, a, type))
01157 return soap->error;
01158 return SOAP_OK;
01159 }
01160
01161 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)
01162 {
01163 if (soap_out_PointerTo_ns1__Revisions(soap, "ns1:Revisions", -1, &a->ns1__Revisions, ""))
01164 return soap->error;
01165 return SOAP_OK;
01166 }
01167
01168 SOAP_FMAC3 struct __ns3__Revisions * SOAP_FMAC4 soap_get___ns3__Revisions(struct soap *soap, struct __ns3__Revisions *p, const char *tag, const char *type)
01169 {
01170 if ((p = soap_in___ns3__Revisions(soap, tag, p, type)))
01171 if (soap_getindependent(soap))
01172 return NULL;
01173 return p;
01174 }
01175
01176 SOAP_FMAC3 struct __ns3__Revisions * SOAP_FMAC4 soap_in___ns3__Revisions(struct soap *soap, const char *tag, struct __ns3__Revisions *a, const char *type)
01177 {
01178 short soap_flag_ns1__Revisions = 1;
01179 short soap_flag;
01180 a = (struct __ns3__Revisions *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__Revisions, sizeof(struct __ns3__Revisions), 0, NULL, NULL, NULL);
01181 if (!a)
01182 return NULL;
01183 soap_default___ns3__Revisions(soap, a);
01184 for (soap_flag = 0;; soap_flag = 1)
01185 { soap->error = SOAP_TAG_MISMATCH;
01186 if (soap_flag_ns1__Revisions && soap->error == SOAP_TAG_MISMATCH)
01187 if (soap_in_PointerTo_ns1__Revisions(soap, "ns1:Revisions", &a->ns1__Revisions, ""))
01188 { soap_flag_ns1__Revisions--;
01189 continue;
01190 }
01191 if (soap->error == SOAP_TAG_MISMATCH)
01192 if (soap_flag)
01193 { soap->error = SOAP_OK;
01194 break;
01195 }
01196 if (soap->error == SOAP_NO_TAG)
01197 break;
01198 if (soap->error)
01199 return NULL;
01200 }
01201 return a;
01202 }
01203
01204 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__ObjNearPosn(struct soap *soap, struct __ns3__ObjNearPosn *a)
01205 {
01206 (void)soap; (void)a;
01207 a->ns1__ObjNearPosn = NULL;
01208 }
01209
01210 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__ObjNearPosn(struct soap *soap, const struct __ns3__ObjNearPosn *a)
01211 {
01212 (void)soap; (void)a;
01213 soap_serialize_PointerTo_ns1__ObjNearPosn(soap, &a->ns1__ObjNearPosn);
01214 }
01215
01216 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__ObjNearPosn(struct soap *soap, const struct __ns3__ObjNearPosn *a, const char *tag, const char *type)
01217 {
01218 register int id = 0;
01219 if (soap_out___ns3__ObjNearPosn(soap, tag, id, a, type))
01220 return soap->error;
01221 return SOAP_OK;
01222 }
01223
01224 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__ObjNearPosn(struct soap *soap, const char *tag, int id, const struct __ns3__ObjNearPosn *a, const char *type)
01225 {
01226 if (soap_out_PointerTo_ns1__ObjNearPosn(soap, "ns1:ObjNearPosn", -1, &a->ns1__ObjNearPosn, ""))
01227 return soap->error;
01228 return SOAP_OK;
01229 }
01230
01231 SOAP_FMAC3 struct __ns3__ObjNearPosn * SOAP_FMAC4 soap_get___ns3__ObjNearPosn(struct soap *soap, struct __ns3__ObjNearPosn *p, const char *tag, const char *type)
01232 {
01233 if ((p = soap_in___ns3__ObjNearPosn(soap, tag, p, type)))
01234 if (soap_getindependent(soap))
01235 return NULL;
01236 return p;
01237 }
01238
01239 SOAP_FMAC3 struct __ns3__ObjNearPosn * SOAP_FMAC4 soap_in___ns3__ObjNearPosn(struct soap *soap, const char *tag, struct __ns3__ObjNearPosn *a, const char *type)
01240 {
01241 short soap_flag_ns1__ObjNearPosn = 1;
01242 short soap_flag;
01243 a = (struct __ns3__ObjNearPosn *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__ObjNearPosn, sizeof(struct __ns3__ObjNearPosn), 0, NULL, NULL, NULL);
01244 if (!a)
01245 return NULL;
01246 soap_default___ns3__ObjNearPosn(soap, a);
01247 for (soap_flag = 0;; soap_flag = 1)
01248 { soap->error = SOAP_TAG_MISMATCH;
01249 if (soap_flag_ns1__ObjNearPosn && soap->error == SOAP_TAG_MISMATCH)
01250 if (soap_in_PointerTo_ns1__ObjNearPosn(soap, "ns1:ObjNearPosn", &a->ns1__ObjNearPosn, ""))
01251 { soap_flag_ns1__ObjNearPosn--;
01252 continue;
01253 }
01254 if (soap->error == SOAP_TAG_MISMATCH)
01255 if (soap_flag)
01256 { soap->error = SOAP_OK;
01257 break;
01258 }
01259 if (soap->error == SOAP_NO_TAG)
01260 break;
01261 if (soap->error)
01262 return NULL;
01263 }
01264 return a;
01265 }
01266
01267 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__ObjNearName(struct soap *soap, struct __ns3__ObjNearName *a)
01268 {
01269 (void)soap; (void)a;
01270 a->ns1__ObjNearName = NULL;
01271 }
01272
01273 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__ObjNearName(struct soap *soap, const struct __ns3__ObjNearName *a)
01274 {
01275 (void)soap; (void)a;
01276 soap_serialize_PointerTo_ns1__ObjNearName(soap, &a->ns1__ObjNearName);
01277 }
01278
01279 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__ObjNearName(struct soap *soap, const struct __ns3__ObjNearName *a, const char *tag, const char *type)
01280 {
01281 register int id = 0;
01282 if (soap_out___ns3__ObjNearName(soap, tag, id, a, type))
01283 return soap->error;
01284 return SOAP_OK;
01285 }
01286
01287 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__ObjNearName(struct soap *soap, const char *tag, int id, const struct __ns3__ObjNearName *a, const char *type)
01288 {
01289 if (soap_out_PointerTo_ns1__ObjNearName(soap, "ns1:ObjNearName", -1, &a->ns1__ObjNearName, ""))
01290 return soap->error;
01291 return SOAP_OK;
01292 }
01293
01294 SOAP_FMAC3 struct __ns3__ObjNearName * SOAP_FMAC4 soap_get___ns3__ObjNearName(struct soap *soap, struct __ns3__ObjNearName *p, const char *tag, const char *type)
01295 {
01296 if ((p = soap_in___ns3__ObjNearName(soap, tag, p, type)))
01297 if (soap_getindependent(soap))
01298 return NULL;
01299 return p;
01300 }
01301
01302 SOAP_FMAC3 struct __ns3__ObjNearName * SOAP_FMAC4 soap_in___ns3__ObjNearName(struct soap *soap, const char *tag, struct __ns3__ObjNearName *a, const char *type)
01303 {
01304 short soap_flag_ns1__ObjNearName = 1;
01305 short soap_flag;
01306 a = (struct __ns3__ObjNearName *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__ObjNearName, sizeof(struct __ns3__ObjNearName), 0, NULL, NULL, NULL);
01307 if (!a)
01308 return NULL;
01309 soap_default___ns3__ObjNearName(soap, a);
01310 for (soap_flag = 0;; soap_flag = 1)
01311 { soap->error = SOAP_TAG_MISMATCH;
01312 if (soap_flag_ns1__ObjNearName && soap->error == SOAP_TAG_MISMATCH)
01313 if (soap_in_PointerTo_ns1__ObjNearName(soap, "ns1:ObjNearName", &a->ns1__ObjNearName, ""))
01314 { soap_flag_ns1__ObjNearName--;
01315 continue;
01316 }
01317 if (soap->error == SOAP_TAG_MISMATCH)
01318 if (soap_flag)
01319 { soap->error = SOAP_OK;
01320 break;
01321 }
01322 if (soap->error == SOAP_NO_TAG)
01323 break;
01324 if (soap->error)
01325 return NULL;
01326 }
01327 return a;
01328 }
01329
01330 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns3__ObjByName(struct soap *soap, struct __ns3__ObjByName *a)
01331 {
01332 (void)soap; (void)a;
01333 a->ns1__ObjByName = NULL;
01334 }
01335
01336 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns3__ObjByName(struct soap *soap, const struct __ns3__ObjByName *a)
01337 {
01338 (void)soap; (void)a;
01339 soap_serialize_PointerTo_ns1__ObjByName(soap, &a->ns1__ObjByName);
01340 }
01341
01342 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns3__ObjByName(struct soap *soap, const struct __ns3__ObjByName *a, const char *tag, const char *type)
01343 {
01344 register int id = 0;
01345 if (soap_out___ns3__ObjByName(soap, tag, id, a, type))
01346 return soap->error;
01347 return SOAP_OK;
01348 }
01349
01350 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns3__ObjByName(struct soap *soap, const char *tag, int id, const struct __ns3__ObjByName *a, const char *type)
01351 {
01352 if (soap_out_PointerTo_ns1__ObjByName(soap, "ns1:ObjByName", -1, &a->ns1__ObjByName, ""))
01353 return soap->error;
01354 return SOAP_OK;
01355 }
01356
01357 SOAP_FMAC3 struct __ns3__ObjByName * SOAP_FMAC4 soap_get___ns3__ObjByName(struct soap *soap, struct __ns3__ObjByName *p, const char *tag, const char *type)
01358 {
01359 if ((p = soap_in___ns3__ObjByName(soap, tag, p, type)))
01360 if (soap_getindependent(soap))
01361 return NULL;
01362 return p;
01363 }
01364
01365 SOAP_FMAC3 struct __ns3__ObjByName * SOAP_FMAC4 soap_in___ns3__ObjByName(struct soap *soap, const char *tag, struct __ns3__ObjByName *a, const char *type)
01366 {
01367 short soap_flag_ns1__ObjByName = 1;
01368 short soap_flag;
01369 a = (struct __ns3__ObjByName *)soap_id_enter(soap, "", a, SOAP_TYPE___ns3__ObjByName, sizeof(struct __ns3__ObjByName), 0, NULL, NULL, NULL);
01370 if (!a)
01371 return NULL;
01372 soap_default___ns3__ObjByName(soap, a);
01373 for (soap_flag = 0;; soap_flag = 1)
01374 { soap->error = SOAP_TAG_MISMATCH;
01375 if (soap_flag_ns1__ObjByName && soap->error == SOAP_TAG_MISMATCH)
01376 if (soap_in_PointerTo_ns1__ObjByName(soap, "ns1:ObjByName", &a->ns1__ObjByName, ""))
01377 { soap_flag_ns1__ObjByName--;
01378 continue;
01379 }
01380 if (soap->error == SOAP_TAG_MISMATCH)
01381 if (soap_flag)
01382 { soap->error = SOAP_OK;
01383 break;
01384 }
01385 if (soap->error == SOAP_NO_TAG)
01386 break;
01387 if (soap->error)
01388 return NULL;
01389 }
01390 return a;
01391 }
01392
01393 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__Revisions(struct soap *soap, struct __ns2__Revisions *a)
01394 {
01395 (void)soap; (void)a;
01396 a->ns1__Revisions = NULL;
01397 }
01398
01399 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__Revisions(struct soap *soap, const struct __ns2__Revisions *a)
01400 {
01401 (void)soap; (void)a;
01402 soap_serialize_PointerTo_ns1__Revisions(soap, &a->ns1__Revisions);
01403 }
01404
01405 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__Revisions(struct soap *soap, const struct __ns2__Revisions *a, const char *tag, const char *type)
01406 {
01407 register int id = 0;
01408 if (soap_out___ns2__Revisions(soap, tag, id, a, type))
01409 return soap->error;
01410 return SOAP_OK;
01411 }
01412
01413 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)
01414 {
01415 if (soap_out_PointerTo_ns1__Revisions(soap, "ns1:Revisions", -1, &a->ns1__Revisions, ""))
01416 return soap->error;
01417 return SOAP_OK;
01418 }
01419
01420 SOAP_FMAC3 struct __ns2__Revisions * SOAP_FMAC4 soap_get___ns2__Revisions(struct soap *soap, struct __ns2__Revisions *p, const char *tag, const char *type)
01421 {
01422 if ((p = soap_in___ns2__Revisions(soap, tag, p, type)))
01423 if (soap_getindependent(soap))
01424 return NULL;
01425 return p;
01426 }
01427
01428 SOAP_FMAC3 struct __ns2__Revisions * SOAP_FMAC4 soap_in___ns2__Revisions(struct soap *soap, const char *tag, struct __ns2__Revisions *a, const char *type)
01429 {
01430 short soap_flag_ns1__Revisions = 1;
01431 short soap_flag;
01432 a = (struct __ns2__Revisions *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__Revisions, sizeof(struct __ns2__Revisions), 0, NULL, NULL, NULL);
01433 if (!a)
01434 return NULL;
01435 soap_default___ns2__Revisions(soap, a);
01436 for (soap_flag = 0;; soap_flag = 1)
01437 { soap->error = SOAP_TAG_MISMATCH;
01438 if (soap_flag_ns1__Revisions && soap->error == SOAP_TAG_MISMATCH)
01439 if (soap_in_PointerTo_ns1__Revisions(soap, "ns1:Revisions", &a->ns1__Revisions, ""))
01440 { soap_flag_ns1__Revisions--;
01441 continue;
01442 }
01443 if (soap->error == SOAP_TAG_MISMATCH)
01444 if (soap_flag)
01445 { soap->error = SOAP_OK;
01446 break;
01447 }
01448 if (soap->error == SOAP_NO_TAG)
01449 break;
01450 if (soap->error)
01451 return NULL;
01452 }
01453 return a;
01454 }
01455
01456 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__ObjNearPosn(struct soap *soap, struct __ns2__ObjNearPosn *a)
01457 {
01458 (void)soap; (void)a;
01459 a->ns1__ObjNearPosn = NULL;
01460 }
01461
01462 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__ObjNearPosn(struct soap *soap, const struct __ns2__ObjNearPosn *a)
01463 {
01464 (void)soap; (void)a;
01465 soap_serialize_PointerTo_ns1__ObjNearPosn(soap, &a->ns1__ObjNearPosn);
01466 }
01467
01468 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__ObjNearPosn(struct soap *soap, const struct __ns2__ObjNearPosn *a, const char *tag, const char *type)
01469 {
01470 register int id = 0;
01471 if (soap_out___ns2__ObjNearPosn(soap, tag, id, a, type))
01472 return soap->error;
01473 return SOAP_OK;
01474 }
01475
01476 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__ObjNearPosn(struct soap *soap, const char *tag, int id, const struct __ns2__ObjNearPosn *a, const char *type)
01477 {
01478 if (soap_out_PointerTo_ns1__ObjNearPosn(soap, "ns1:ObjNearPosn", -1, &a->ns1__ObjNearPosn, ""))
01479 return soap->error;
01480 return SOAP_OK;
01481 }
01482
01483 SOAP_FMAC3 struct __ns2__ObjNearPosn * SOAP_FMAC4 soap_get___ns2__ObjNearPosn(struct soap *soap, struct __ns2__ObjNearPosn *p, const char *tag, const char *type)
01484 {
01485 if ((p = soap_in___ns2__ObjNearPosn(soap, tag, p, type)))
01486 if (soap_getindependent(soap))
01487 return NULL;
01488 return p;
01489 }
01490
01491 SOAP_FMAC3 struct __ns2__ObjNearPosn * SOAP_FMAC4 soap_in___ns2__ObjNearPosn(struct soap *soap, const char *tag, struct __ns2__ObjNearPosn *a, const char *type)
01492 {
01493 short soap_flag_ns1__ObjNearPosn = 1;
01494 short soap_flag;
01495 a = (struct __ns2__ObjNearPosn *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__ObjNearPosn, sizeof(struct __ns2__ObjNearPosn), 0, NULL, NULL, NULL);
01496 if (!a)
01497 return NULL;
01498 soap_default___ns2__ObjNearPosn(soap, a);
01499 for (soap_flag = 0;; soap_flag = 1)
01500 { soap->error = SOAP_TAG_MISMATCH;
01501 if (soap_flag_ns1__ObjNearPosn && soap->error == SOAP_TAG_MISMATCH)
01502 if (soap_in_PointerTo_ns1__ObjNearPosn(soap, "ns1:ObjNearPosn", &a->ns1__ObjNearPosn, ""))
01503 { soap_flag_ns1__ObjNearPosn--;
01504 continue;
01505 }
01506 if (soap->error == SOAP_TAG_MISMATCH)
01507 if (soap_flag)
01508 { soap->error = SOAP_OK;
01509 break;
01510 }
01511 if (soap->error == SOAP_NO_TAG)
01512 break;
01513 if (soap->error)
01514 return NULL;
01515 }
01516 return a;
01517 }
01518
01519 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__ObjNearName(struct soap *soap, struct __ns2__ObjNearName *a)
01520 {
01521 (void)soap; (void)a;
01522 a->ns1__ObjNearName = NULL;
01523 }
01524
01525 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__ObjNearName(struct soap *soap, const struct __ns2__ObjNearName *a)
01526 {
01527 (void)soap; (void)a;
01528 soap_serialize_PointerTo_ns1__ObjNearName(soap, &a->ns1__ObjNearName);
01529 }
01530
01531 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__ObjNearName(struct soap *soap, const struct __ns2__ObjNearName *a, const char *tag, const char *type)
01532 {
01533 register int id = 0;
01534 if (soap_out___ns2__ObjNearName(soap, tag, id, a, type))
01535 return soap->error;
01536 return SOAP_OK;
01537 }
01538
01539 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__ObjNearName(struct soap *soap, const char *tag, int id, const struct __ns2__ObjNearName *a, const char *type)
01540 {
01541 if (soap_out_PointerTo_ns1__ObjNearName(soap, "ns1:ObjNearName", -1, &a->ns1__ObjNearName, ""))
01542 return soap->error;
01543 return SOAP_OK;
01544 }
01545
01546 SOAP_FMAC3 struct __ns2__ObjNearName * SOAP_FMAC4 soap_get___ns2__ObjNearName(struct soap *soap, struct __ns2__ObjNearName *p, const char *tag, const char *type)
01547 {
01548 if ((p = soap_in___ns2__ObjNearName(soap, tag, p, type)))
01549 if (soap_getindependent(soap))
01550 return NULL;
01551 return p;
01552 }
01553
01554 SOAP_FMAC3 struct __ns2__ObjNearName * SOAP_FMAC4 soap_in___ns2__ObjNearName(struct soap *soap, const char *tag, struct __ns2__ObjNearName *a, const char *type)
01555 {
01556 short soap_flag_ns1__ObjNearName = 1;
01557 short soap_flag;
01558 a = (struct __ns2__ObjNearName *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__ObjNearName, sizeof(struct __ns2__ObjNearName), 0, NULL, NULL, NULL);
01559 if (!a)
01560 return NULL;
01561 soap_default___ns2__ObjNearName(soap, a);
01562 for (soap_flag = 0;; soap_flag = 1)
01563 { soap->error = SOAP_TAG_MISMATCH;
01564 if (soap_flag_ns1__ObjNearName && soap->error == SOAP_TAG_MISMATCH)
01565 if (soap_in_PointerTo_ns1__ObjNearName(soap, "ns1:ObjNearName", &a->ns1__ObjNearName, ""))
01566 { soap_flag_ns1__ObjNearName--;
01567 continue;
01568 }
01569 if (soap->error == SOAP_TAG_MISMATCH)
01570 if (soap_flag)
01571 { soap->error = SOAP_OK;
01572 break;
01573 }
01574 if (soap->error == SOAP_NO_TAG)
01575 break;
01576 if (soap->error)
01577 return NULL;
01578 }
01579 return a;
01580 }
01581
01582 SOAP_FMAC3 void SOAP_FMAC4 soap_default___ns2__ObjByName(struct soap *soap, struct __ns2__ObjByName *a)
01583 {
01584 (void)soap; (void)a;
01585 a->ns1__ObjByName = NULL;
01586 }
01587
01588 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___ns2__ObjByName(struct soap *soap, const struct __ns2__ObjByName *a)
01589 {
01590 (void)soap; (void)a;
01591 soap_serialize_PointerTo_ns1__ObjByName(soap, &a->ns1__ObjByName);
01592 }
01593
01594 SOAP_FMAC3 int SOAP_FMAC4 soap_put___ns2__ObjByName(struct soap *soap, const struct __ns2__ObjByName *a, const char *tag, const char *type)
01595 {
01596 register int id = 0;
01597 if (soap_out___ns2__ObjByName(soap, tag, id, a, type))
01598 return soap->error;
01599 return SOAP_OK;
01600 }
01601
01602 SOAP_FMAC3 int SOAP_FMAC4 soap_out___ns2__ObjByName(struct soap *soap, const char *tag, int id, const struct __ns2__ObjByName *a, const char *type)
01603 {
01604 if (soap_out_PointerTo_ns1__ObjByName(soap, "ns1:ObjByName", -1, &a->ns1__ObjByName, ""))
01605 return soap->error;
01606 return SOAP_OK;
01607 }
01608
01609 SOAP_FMAC3 struct __ns2__ObjByName * SOAP_FMAC4 soap_get___ns2__ObjByName(struct soap *soap, struct __ns2__ObjByName *p, const char *tag, const char *type)
01610 {
01611 if ((p = soap_in___ns2__ObjByName(soap, tag, p, type)))
01612 if (soap_getindependent(soap))
01613 return NULL;
01614 return p;
01615 }
01616
01617 SOAP_FMAC3 struct __ns2__ObjByName * SOAP_FMAC4 soap_in___ns2__ObjByName(struct soap *soap, const char *tag, struct __ns2__ObjByName *a, const char *type)
01618 {
01619 short soap_flag_ns1__ObjByName = 1;
01620 short soap_flag;
01621 a = (struct __ns2__ObjByName *)soap_id_enter(soap, "", a, SOAP_TYPE___ns2__ObjByName, sizeof(struct __ns2__ObjByName), 0, NULL, NULL, NULL);
01622 if (!a)
01623 return NULL;
01624 soap_default___ns2__ObjByName(soap, a);
01625 for (soap_flag = 0;; soap_flag = 1)
01626 { soap->error = SOAP_TAG_MISMATCH;
01627 if (soap_flag_ns1__ObjByName && soap->error == SOAP_TAG_MISMATCH)
01628 if (soap_in_PointerTo_ns1__ObjByName(soap, "ns1:ObjByName", &a->ns1__ObjByName, ""))
01629 { soap_flag_ns1__ObjByName--;
01630 continue;
01631 }
01632 if (soap->error == SOAP_TAG_MISMATCH)
01633 if (soap_flag)
01634 { soap->error = SOAP_OK;
01635 break;
01636 }
01637 if (soap->error == SOAP_NO_TAG)
01638 break;
01639 if (soap->error)
01640 return NULL;
01641 }
01642 return a;
01643 }
01644
01645 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *a)
01646 {
01647 (void)soap; (void)a;
01648 a->RevisionsResult = NULL;
01649 }
01650
01651 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__RevisionsResponse(struct soap *soap, const struct _ns1__RevisionsResponse *a)
01652 {
01653 (void)soap; (void)a;
01654 soap_serialize_PointerTons1__ArrayOfString(soap, &a->RevisionsResult);
01655 }
01656
01657 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__RevisionsResponse(struct soap *soap, const struct _ns1__RevisionsResponse *a, const char *tag, const char *type)
01658 {
01659 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__RevisionsResponse);
01660 if (soap_out__ns1__RevisionsResponse(soap, tag, id, a, type))
01661 return soap->error;
01662 return soap_putindependent(soap);
01663 }
01664
01665 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)
01666 {
01667 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__RevisionsResponse), type))
01668 return soap->error;
01669 if (a->RevisionsResult)
01670 soap_element_result(soap, "ns1:RevisionsResult");
01671 if (soap_out_PointerTons1__ArrayOfString(soap, "ns1:RevisionsResult", -1, &a->RevisionsResult, ""))
01672 return soap->error;
01673 return soap_element_end_out(soap, tag);
01674 }
01675
01676 SOAP_FMAC3 struct _ns1__RevisionsResponse * SOAP_FMAC4 soap_get__ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *p, const char *tag, const char *type)
01677 {
01678 if ((p = soap_in__ns1__RevisionsResponse(soap, tag, p, type)))
01679 if (soap_getindependent(soap))
01680 return NULL;
01681 return p;
01682 }
01683
01684 SOAP_FMAC3 struct _ns1__RevisionsResponse * SOAP_FMAC4 soap_in__ns1__RevisionsResponse(struct soap *soap, const char *tag, struct _ns1__RevisionsResponse *a, const char *type)
01685 {
01686 short soap_flag_RevisionsResult = 1;
01687 if (soap_element_begin_in(soap, tag, 0, type))
01688 return NULL;
01689 a = (struct _ns1__RevisionsResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__RevisionsResponse, sizeof(struct _ns1__RevisionsResponse), 0, NULL, NULL, NULL);
01690 if (!a)
01691 return NULL;
01692 soap_default__ns1__RevisionsResponse(soap, a);
01693 if (soap->body && !*soap->href)
01694 {
01695 for (;;)
01696 { soap->error = SOAP_TAG_MISMATCH;
01697 if (soap_flag_RevisionsResult && soap->error == SOAP_TAG_MISMATCH)
01698 if (soap_in_PointerTons1__ArrayOfString(soap, "ns1:RevisionsResult", &a->RevisionsResult, "ns1:ArrayOfString"))
01699 { soap_flag_RevisionsResult--;
01700 continue;
01701 }
01702 soap_check_result(soap, "ns1:RevisionsResult");
01703 if (soap->error == SOAP_TAG_MISMATCH)
01704 soap->error = soap_ignore_element(soap);
01705 if (soap->error == SOAP_NO_TAG)
01706 break;
01707 if (soap->error)
01708 return NULL;
01709 }
01710 if (soap_element_end_in(soap, tag))
01711 return NULL;
01712 }
01713 else
01714 { a = (struct _ns1__RevisionsResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__RevisionsResponse, 0, sizeof(struct _ns1__RevisionsResponse), 0, NULL);
01715 if (soap->body && soap_element_end_in(soap, tag))
01716 return NULL;
01717 }
01718 return a;
01719 }
01720
01721 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__Revisions(struct soap *soap, struct _ns1__Revisions *a)
01722 {
01723 (void)soap; (void)a;
01724 }
01725
01726 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__Revisions(struct soap *soap, const struct _ns1__Revisions *a)
01727 {
01728 (void)soap; (void)a;
01729 }
01730
01731 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__Revisions(struct soap *soap, const struct _ns1__Revisions *a, const char *tag, const char *type)
01732 {
01733 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__Revisions);
01734 if (soap_out__ns1__Revisions(soap, tag, id, a, type))
01735 return soap->error;
01736 return soap_putindependent(soap);
01737 }
01738
01739 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)
01740 {
01741 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__Revisions), type))
01742 return soap->error;
01743 return soap_element_end_out(soap, tag);
01744 }
01745
01746 SOAP_FMAC3 struct _ns1__Revisions * SOAP_FMAC4 soap_get__ns1__Revisions(struct soap *soap, struct _ns1__Revisions *p, const char *tag, const char *type)
01747 {
01748 if ((p = soap_in__ns1__Revisions(soap, tag, p, type)))
01749 if (soap_getindependent(soap))
01750 return NULL;
01751 return p;
01752 }
01753
01754 SOAP_FMAC3 struct _ns1__Revisions * SOAP_FMAC4 soap_in__ns1__Revisions(struct soap *soap, const char *tag, struct _ns1__Revisions *a, const char *type)
01755 {
01756 if (soap_element_begin_in(soap, tag, 0, type))
01757 return NULL;
01758 a = (struct _ns1__Revisions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__Revisions, sizeof(struct _ns1__Revisions), 0, NULL, NULL, NULL);
01759 if (!a)
01760 return NULL;
01761 soap_default__ns1__Revisions(soap, a);
01762 if (soap->body && !*soap->href)
01763 {
01764 for (;;)
01765 { soap->error = SOAP_TAG_MISMATCH;
01766 if (soap->error == SOAP_TAG_MISMATCH)
01767 soap->error = soap_ignore_element(soap);
01768 if (soap->error == SOAP_NO_TAG)
01769 break;
01770 if (soap->error)
01771 return NULL;
01772 }
01773 if (soap_element_end_in(soap, tag))
01774 return NULL;
01775 }
01776 else
01777 { a = (struct _ns1__Revisions *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__Revisions, 0, sizeof(struct _ns1__Revisions), 0, NULL);
01778 if (soap->body && soap_element_end_in(soap, tag))
01779 return NULL;
01780 }
01781 return a;
01782 }
01783
01784 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ObjNearPosnResponse(struct soap *soap, struct _ns1__ObjNearPosnResponse *a)
01785 {
01786 (void)soap; (void)a;
01787 a->ObjNearPosnResult = NULL;
01788 }
01789
01790 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ObjNearPosnResponse(struct soap *soap, const struct _ns1__ObjNearPosnResponse *a)
01791 {
01792 (void)soap; (void)a;
01793 soap_serialize_PointerTons1__ArrayOfObjInfo(soap, &a->ObjNearPosnResult);
01794 }
01795
01796 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ObjNearPosnResponse(struct soap *soap, const struct _ns1__ObjNearPosnResponse *a, const char *tag, const char *type)
01797 {
01798 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ObjNearPosnResponse);
01799 if (soap_out__ns1__ObjNearPosnResponse(soap, tag, id, a, type))
01800 return soap->error;
01801 return soap_putindependent(soap);
01802 }
01803
01804 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ObjNearPosnResponse(struct soap *soap, const char *tag, int id, const struct _ns1__ObjNearPosnResponse *a, const char *type)
01805 {
01806 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ObjNearPosnResponse), type))
01807 return soap->error;
01808 if (a->ObjNearPosnResult)
01809 soap_element_result(soap, "ns1:ObjNearPosnResult");
01810 if (soap_out_PointerTons1__ArrayOfObjInfo(soap, "ns1:ObjNearPosnResult", -1, &a->ObjNearPosnResult, ""))
01811 return soap->error;
01812 return soap_element_end_out(soap, tag);
01813 }
01814
01815 SOAP_FMAC3 struct _ns1__ObjNearPosnResponse * SOAP_FMAC4 soap_get__ns1__ObjNearPosnResponse(struct soap *soap, struct _ns1__ObjNearPosnResponse *p, const char *tag, const char *type)
01816 {
01817 if ((p = soap_in__ns1__ObjNearPosnResponse(soap, tag, p, type)))
01818 if (soap_getindependent(soap))
01819 return NULL;
01820 return p;
01821 }
01822
01823 SOAP_FMAC3 struct _ns1__ObjNearPosnResponse * SOAP_FMAC4 soap_in__ns1__ObjNearPosnResponse(struct soap *soap, const char *tag, struct _ns1__ObjNearPosnResponse *a, const char *type)
01824 {
01825 short soap_flag_ObjNearPosnResult = 1;
01826 if (soap_element_begin_in(soap, tag, 0, type))
01827 return NULL;
01828 a = (struct _ns1__ObjNearPosnResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ObjNearPosnResponse, sizeof(struct _ns1__ObjNearPosnResponse), 0, NULL, NULL, NULL);
01829 if (!a)
01830 return NULL;
01831 soap_default__ns1__ObjNearPosnResponse(soap, a);
01832 if (soap->body && !*soap->href)
01833 {
01834 for (;;)
01835 { soap->error = SOAP_TAG_MISMATCH;
01836 if (soap_flag_ObjNearPosnResult && soap->error == SOAP_TAG_MISMATCH)
01837 if (soap_in_PointerTons1__ArrayOfObjInfo(soap, "ns1:ObjNearPosnResult", &a->ObjNearPosnResult, "ns1:ArrayOfObjInfo"))
01838 { soap_flag_ObjNearPosnResult--;
01839 continue;
01840 }
01841 soap_check_result(soap, "ns1:ObjNearPosnResult");
01842 if (soap->error == SOAP_TAG_MISMATCH)
01843 soap->error = soap_ignore_element(soap);
01844 if (soap->error == SOAP_NO_TAG)
01845 break;
01846 if (soap->error)
01847 return NULL;
01848 }
01849 if (soap_element_end_in(soap, tag))
01850 return NULL;
01851 }
01852 else
01853 { a = (struct _ns1__ObjNearPosnResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ObjNearPosnResponse, 0, sizeof(struct _ns1__ObjNearPosnResponse), 0, NULL);
01854 if (soap->body && soap_element_end_in(soap, tag))
01855 return NULL;
01856 }
01857 return a;
01858 }
01859
01860 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ObjNearPosn(struct soap *soap, struct _ns1__ObjNearPosn *a)
01861 {
01862 (void)soap; (void)a;
01863 soap_default_double(soap, &a->ra);
01864 soap_default_double(soap, &a->dec);
01865 soap_default_double(soap, &a->radius);
01866 }
01867
01868 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ObjNearPosn(struct soap *soap, const struct _ns1__ObjNearPosn *a)
01869 {
01870 (void)soap; (void)a;
01871 }
01872
01873 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ObjNearPosn(struct soap *soap, const struct _ns1__ObjNearPosn *a, const char *tag, const char *type)
01874 {
01875 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ObjNearPosn);
01876 if (soap_out__ns1__ObjNearPosn(soap, tag, id, a, type))
01877 return soap->error;
01878 return soap_putindependent(soap);
01879 }
01880
01881 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ObjNearPosn(struct soap *soap, const char *tag, int id, const struct _ns1__ObjNearPosn *a, const char *type)
01882 {
01883 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ObjNearPosn), type))
01884 return soap->error;
01885 if (soap_out_double(soap, "ns1:ra", -1, &a->ra, ""))
01886 return soap->error;
01887 if (soap_out_double(soap, "ns1:dec", -1, &a->dec, ""))
01888 return soap->error;
01889 if (soap_out_double(soap, "ns1:radius", -1, &a->radius, ""))
01890 return soap->error;
01891 return soap_element_end_out(soap, tag);
01892 }
01893
01894 SOAP_FMAC3 struct _ns1__ObjNearPosn * SOAP_FMAC4 soap_get__ns1__ObjNearPosn(struct soap *soap, struct _ns1__ObjNearPosn *p, const char *tag, const char *type)
01895 {
01896 if ((p = soap_in__ns1__ObjNearPosn(soap, tag, p, type)))
01897 if (soap_getindependent(soap))
01898 return NULL;
01899 return p;
01900 }
01901
01902 SOAP_FMAC3 struct _ns1__ObjNearPosn * SOAP_FMAC4 soap_in__ns1__ObjNearPosn(struct soap *soap, const char *tag, struct _ns1__ObjNearPosn *a, const char *type)
01903 {
01904 short soap_flag_ra = 1, soap_flag_dec = 1, soap_flag_radius = 1;
01905 if (soap_element_begin_in(soap, tag, 0, type))
01906 return NULL;
01907 a = (struct _ns1__ObjNearPosn *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ObjNearPosn, sizeof(struct _ns1__ObjNearPosn), 0, NULL, NULL, NULL);
01908 if (!a)
01909 return NULL;
01910 soap_default__ns1__ObjNearPosn(soap, a);
01911 if (soap->body && !*soap->href)
01912 {
01913 for (;;)
01914 { soap->error = SOAP_TAG_MISMATCH;
01915 if (soap_flag_ra && soap->error == SOAP_TAG_MISMATCH)
01916 if (soap_in_double(soap, "ns1:ra", &a->ra, "xsd:double"))
01917 { soap_flag_ra--;
01918 continue;
01919 }
01920 if (soap_flag_dec && soap->error == SOAP_TAG_MISMATCH)
01921 if (soap_in_double(soap, "ns1:dec", &a->dec, "xsd:double"))
01922 { soap_flag_dec--;
01923 continue;
01924 }
01925 if (soap_flag_radius && soap->error == SOAP_TAG_MISMATCH)
01926 if (soap_in_double(soap, "ns1:radius", &a->radius, "xsd:double"))
01927 { soap_flag_radius--;
01928 continue;
01929 }
01930 if (soap->error == SOAP_TAG_MISMATCH)
01931 soap->error = soap_ignore_element(soap);
01932 if (soap->error == SOAP_NO_TAG)
01933 break;
01934 if (soap->error)
01935 return NULL;
01936 }
01937 if (soap_element_end_in(soap, tag))
01938 return NULL;
01939 }
01940 else
01941 { a = (struct _ns1__ObjNearPosn *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ObjNearPosn, 0, sizeof(struct _ns1__ObjNearPosn), 0, NULL);
01942 if (soap->body && soap_element_end_in(soap, tag))
01943 return NULL;
01944 }
01945 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ra > 0 || soap_flag_dec > 0 || soap_flag_radius > 0))
01946 { soap->error = SOAP_OCCURS;
01947 return NULL;
01948 }
01949 return a;
01950 }
01951
01952 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ObjNearNameResponse(struct soap *soap, struct _ns1__ObjNearNameResponse *a)
01953 {
01954 (void)soap; (void)a;
01955 a->ObjNearNameResult = NULL;
01956 }
01957
01958 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ObjNearNameResponse(struct soap *soap, const struct _ns1__ObjNearNameResponse *a)
01959 {
01960 (void)soap; (void)a;
01961 soap_serialize_PointerTons1__ArrayOfObjInfo(soap, &a->ObjNearNameResult);
01962 }
01963
01964 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ObjNearNameResponse(struct soap *soap, const struct _ns1__ObjNearNameResponse *a, const char *tag, const char *type)
01965 {
01966 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ObjNearNameResponse);
01967 if (soap_out__ns1__ObjNearNameResponse(soap, tag, id, a, type))
01968 return soap->error;
01969 return soap_putindependent(soap);
01970 }
01971
01972 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ObjNearNameResponse(struct soap *soap, const char *tag, int id, const struct _ns1__ObjNearNameResponse *a, const char *type)
01973 {
01974 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ObjNearNameResponse), type))
01975 return soap->error;
01976 if (a->ObjNearNameResult)
01977 soap_element_result(soap, "ns1:ObjNearNameResult");
01978 if (soap_out_PointerTons1__ArrayOfObjInfo(soap, "ns1:ObjNearNameResult", -1, &a->ObjNearNameResult, ""))
01979 return soap->error;
01980 return soap_element_end_out(soap, tag);
01981 }
01982
01983 SOAP_FMAC3 struct _ns1__ObjNearNameResponse * SOAP_FMAC4 soap_get__ns1__ObjNearNameResponse(struct soap *soap, struct _ns1__ObjNearNameResponse *p, const char *tag, const char *type)
01984 {
01985 if ((p = soap_in__ns1__ObjNearNameResponse(soap, tag, p, type)))
01986 if (soap_getindependent(soap))
01987 return NULL;
01988 return p;
01989 }
01990
01991 SOAP_FMAC3 struct _ns1__ObjNearNameResponse * SOAP_FMAC4 soap_in__ns1__ObjNearNameResponse(struct soap *soap, const char *tag, struct _ns1__ObjNearNameResponse *a, const char *type)
01992 {
01993 short soap_flag_ObjNearNameResult = 1;
01994 if (soap_element_begin_in(soap, tag, 0, type))
01995 return NULL;
01996 a = (struct _ns1__ObjNearNameResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ObjNearNameResponse, sizeof(struct _ns1__ObjNearNameResponse), 0, NULL, NULL, NULL);
01997 if (!a)
01998 return NULL;
01999 soap_default__ns1__ObjNearNameResponse(soap, a);
02000 if (soap->body && !*soap->href)
02001 {
02002 for (;;)
02003 { soap->error = SOAP_TAG_MISMATCH;
02004 if (soap_flag_ObjNearNameResult && soap->error == SOAP_TAG_MISMATCH)
02005 if (soap_in_PointerTons1__ArrayOfObjInfo(soap, "ns1:ObjNearNameResult", &a->ObjNearNameResult, "ns1:ArrayOfObjInfo"))
02006 { soap_flag_ObjNearNameResult--;
02007 continue;
02008 }
02009 soap_check_result(soap, "ns1:ObjNearNameResult");
02010 if (soap->error == SOAP_TAG_MISMATCH)
02011 soap->error = soap_ignore_element(soap);
02012 if (soap->error == SOAP_NO_TAG)
02013 break;
02014 if (soap->error)
02015 return NULL;
02016 }
02017 if (soap_element_end_in(soap, tag))
02018 return NULL;
02019 }
02020 else
02021 { a = (struct _ns1__ObjNearNameResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ObjNearNameResponse, 0, sizeof(struct _ns1__ObjNearNameResponse), 0, NULL);
02022 if (soap->body && soap_element_end_in(soap, tag))
02023 return NULL;
02024 }
02025 return a;
02026 }
02027
02028 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ObjNearName(struct soap *soap, struct _ns1__ObjNearName *a)
02029 {
02030 (void)soap; (void)a;
02031 soap_default_string(soap, &a->objname);
02032 soap_default_double(soap, &a->radius);
02033 }
02034
02035 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ObjNearName(struct soap *soap, const struct _ns1__ObjNearName *a)
02036 {
02037 (void)soap; (void)a;
02038 soap_serialize_string(soap, &a->objname);
02039 }
02040
02041 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ObjNearName(struct soap *soap, const struct _ns1__ObjNearName *a, const char *tag, const char *type)
02042 {
02043 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ObjNearName);
02044 if (soap_out__ns1__ObjNearName(soap, tag, id, a, type))
02045 return soap->error;
02046 return soap_putindependent(soap);
02047 }
02048
02049 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ObjNearName(struct soap *soap, const char *tag, int id, const struct _ns1__ObjNearName *a, const char *type)
02050 {
02051 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ObjNearName), type))
02052 return soap->error;
02053 if (soap_out_string(soap, "ns1:objname", -1, &a->objname, ""))
02054 return soap->error;
02055 if (soap_out_double(soap, "ns1:radius", -1, &a->radius, ""))
02056 return soap->error;
02057 return soap_element_end_out(soap, tag);
02058 }
02059
02060 SOAP_FMAC3 struct _ns1__ObjNearName * SOAP_FMAC4 soap_get__ns1__ObjNearName(struct soap *soap, struct _ns1__ObjNearName *p, const char *tag, const char *type)
02061 {
02062 if ((p = soap_in__ns1__ObjNearName(soap, tag, p, type)))
02063 if (soap_getindependent(soap))
02064 return NULL;
02065 return p;
02066 }
02067
02068 SOAP_FMAC3 struct _ns1__ObjNearName * SOAP_FMAC4 soap_in__ns1__ObjNearName(struct soap *soap, const char *tag, struct _ns1__ObjNearName *a, const char *type)
02069 {
02070 short soap_flag_objname = 1, soap_flag_radius = 1;
02071 if (soap_element_begin_in(soap, tag, 0, type))
02072 return NULL;
02073 a = (struct _ns1__ObjNearName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ObjNearName, sizeof(struct _ns1__ObjNearName), 0, NULL, NULL, NULL);
02074 if (!a)
02075 return NULL;
02076 soap_default__ns1__ObjNearName(soap, a);
02077 if (soap->body && !*soap->href)
02078 {
02079 for (;;)
02080 { soap->error = SOAP_TAG_MISMATCH;
02081 if (soap_flag_objname && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02082 if (soap_in_string(soap, "ns1:objname", &a->objname, "xsd:string"))
02083 { soap_flag_objname--;
02084 continue;
02085 }
02086 if (soap_flag_radius && soap->error == SOAP_TAG_MISMATCH)
02087 if (soap_in_double(soap, "ns1:radius", &a->radius, "xsd:double"))
02088 { soap_flag_radius--;
02089 continue;
02090 }
02091 if (soap->error == SOAP_TAG_MISMATCH)
02092 soap->error = soap_ignore_element(soap);
02093 if (soap->error == SOAP_NO_TAG)
02094 break;
02095 if (soap->error)
02096 return NULL;
02097 }
02098 if (soap_element_end_in(soap, tag))
02099 return NULL;
02100 }
02101 else
02102 { a = (struct _ns1__ObjNearName *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ObjNearName, 0, sizeof(struct _ns1__ObjNearName), 0, NULL);
02103 if (soap->body && soap_element_end_in(soap, tag))
02104 return NULL;
02105 }
02106 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_radius > 0))
02107 { soap->error = SOAP_OCCURS;
02108 return NULL;
02109 }
02110 return a;
02111 }
02112
02113 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ObjByNameResponse(struct soap *soap, struct _ns1__ObjByNameResponse *a)
02114 {
02115 (void)soap; (void)a;
02116 a->ObjByNameResult = NULL;
02117 }
02118
02119 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ObjByNameResponse(struct soap *soap, const struct _ns1__ObjByNameResponse *a)
02120 {
02121 (void)soap; (void)a;
02122 soap_serialize_PointerTons1__ObjInfo(soap, &a->ObjByNameResult);
02123 }
02124
02125 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ObjByNameResponse(struct soap *soap, const struct _ns1__ObjByNameResponse *a, const char *tag, const char *type)
02126 {
02127 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ObjByNameResponse);
02128 if (soap_out__ns1__ObjByNameResponse(soap, tag, id, a, type))
02129 return soap->error;
02130 return soap_putindependent(soap);
02131 }
02132
02133 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ObjByNameResponse(struct soap *soap, const char *tag, int id, const struct _ns1__ObjByNameResponse *a, const char *type)
02134 {
02135 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ObjByNameResponse), type))
02136 return soap->error;
02137 if (a->ObjByNameResult)
02138 soap_element_result(soap, "ns1:ObjByNameResult");
02139 if (soap_out_PointerTons1__ObjInfo(soap, "ns1:ObjByNameResult", -1, &a->ObjByNameResult, ""))
02140 return soap->error;
02141 return soap_element_end_out(soap, tag);
02142 }
02143
02144 SOAP_FMAC3 struct _ns1__ObjByNameResponse * SOAP_FMAC4 soap_get__ns1__ObjByNameResponse(struct soap *soap, struct _ns1__ObjByNameResponse *p, const char *tag, const char *type)
02145 {
02146 if ((p = soap_in__ns1__ObjByNameResponse(soap, tag, p, type)))
02147 if (soap_getindependent(soap))
02148 return NULL;
02149 return p;
02150 }
02151
02152 SOAP_FMAC3 struct _ns1__ObjByNameResponse * SOAP_FMAC4 soap_in__ns1__ObjByNameResponse(struct soap *soap, const char *tag, struct _ns1__ObjByNameResponse *a, const char *type)
02153 {
02154 short soap_flag_ObjByNameResult = 1;
02155 if (soap_element_begin_in(soap, tag, 0, type))
02156 return NULL;
02157 a = (struct _ns1__ObjByNameResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ObjByNameResponse, sizeof(struct _ns1__ObjByNameResponse), 0, NULL, NULL, NULL);
02158 if (!a)
02159 return NULL;
02160 soap_default__ns1__ObjByNameResponse(soap, a);
02161 if (soap->body && !*soap->href)
02162 {
02163 for (;;)
02164 { soap->error = SOAP_TAG_MISMATCH;
02165 if (soap_flag_ObjByNameResult && soap->error == SOAP_TAG_MISMATCH)
02166 if (soap_in_PointerTons1__ObjInfo(soap, "ns1:ObjByNameResult", &a->ObjByNameResult, "ns1:ObjInfo"))
02167 { soap_flag_ObjByNameResult--;
02168 continue;
02169 }
02170 soap_check_result(soap, "ns1:ObjByNameResult");
02171 if (soap->error == SOAP_TAG_MISMATCH)
02172 soap->error = soap_ignore_element(soap);
02173 if (soap->error == SOAP_NO_TAG)
02174 break;
02175 if (soap->error)
02176 return NULL;
02177 }
02178 if (soap_element_end_in(soap, tag))
02179 return NULL;
02180 }
02181 else
02182 { a = (struct _ns1__ObjByNameResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ObjByNameResponse, 0, sizeof(struct _ns1__ObjByNameResponse), 0, NULL);
02183 if (soap->body && soap_element_end_in(soap, tag))
02184 return NULL;
02185 }
02186 return a;
02187 }
02188
02189 SOAP_FMAC3 void SOAP_FMAC4 soap_default__ns1__ObjByName(struct soap *soap, struct _ns1__ObjByName *a)
02190 {
02191 (void)soap; (void)a;
02192 soap_default_string(soap, &a->objname);
02193 }
02194
02195 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__ns1__ObjByName(struct soap *soap, const struct _ns1__ObjByName *a)
02196 {
02197 (void)soap; (void)a;
02198 soap_serialize_string(soap, &a->objname);
02199 }
02200
02201 SOAP_FMAC3 int SOAP_FMAC4 soap_put__ns1__ObjByName(struct soap *soap, const struct _ns1__ObjByName *a, const char *tag, const char *type)
02202 {
02203 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__ns1__ObjByName);
02204 if (soap_out__ns1__ObjByName(soap, tag, id, a, type))
02205 return soap->error;
02206 return soap_putindependent(soap);
02207 }
02208
02209 SOAP_FMAC3 int SOAP_FMAC4 soap_out__ns1__ObjByName(struct soap *soap, const char *tag, int id, const struct _ns1__ObjByName *a, const char *type)
02210 {
02211 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__ns1__ObjByName), type))
02212 return soap->error;
02213 if (soap_out_string(soap, "ns1:objname", -1, &a->objname, ""))
02214 return soap->error;
02215 return soap_element_end_out(soap, tag);
02216 }
02217
02218 SOAP_FMAC3 struct _ns1__ObjByName * SOAP_FMAC4 soap_get__ns1__ObjByName(struct soap *soap, struct _ns1__ObjByName *p, const char *tag, const char *type)
02219 {
02220 if ((p = soap_in__ns1__ObjByName(soap, tag, p, type)))
02221 if (soap_getindependent(soap))
02222 return NULL;
02223 return p;
02224 }
02225
02226 SOAP_FMAC3 struct _ns1__ObjByName * SOAP_FMAC4 soap_in__ns1__ObjByName(struct soap *soap, const char *tag, struct _ns1__ObjByName *a, const char *type)
02227 {
02228 short soap_flag_objname = 1;
02229 if (soap_element_begin_in(soap, tag, 0, type))
02230 return NULL;
02231 a = (struct _ns1__ObjByName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE__ns1__ObjByName, sizeof(struct _ns1__ObjByName), 0, NULL, NULL, NULL);
02232 if (!a)
02233 return NULL;
02234 soap_default__ns1__ObjByName(soap, a);
02235 if (soap->body && !*soap->href)
02236 {
02237 for (;;)
02238 { soap->error = SOAP_TAG_MISMATCH;
02239 if (soap_flag_objname && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02240 if (soap_in_string(soap, "ns1:objname", &a->objname, "xsd:string"))
02241 { soap_flag_objname--;
02242 continue;
02243 }
02244 if (soap->error == SOAP_TAG_MISMATCH)
02245 soap->error = soap_ignore_element(soap);
02246 if (soap->error == SOAP_NO_TAG)
02247 break;
02248 if (soap->error)
02249 return NULL;
02250 }
02251 if (soap_element_end_in(soap, tag))
02252 return NULL;
02253 }
02254 else
02255 { a = (struct _ns1__ObjByName *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__ns1__ObjByName, 0, sizeof(struct _ns1__ObjByName), 0, NULL);
02256 if (soap->body && soap_element_end_in(soap, tag))
02257 return NULL;
02258 }
02259 return a;
02260 }
02261
02262 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *a)
02263 {
02264 (void)soap; (void)a;
02265 a->__sizestring = 0;
02266 a->string = NULL;
02267 }
02268
02269 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__ArrayOfString(struct soap *soap, const struct ns1__ArrayOfString *a)
02270 {
02271 (void)soap; (void)a;
02272 if (a->string)
02273 { int i;
02274 for (i = 0; i < a->__sizestring; i++)
02275 {
02276 soap_serialize_string(soap, a->string + i);
02277 }
02278 }
02279 }
02280
02281 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__ArrayOfString(struct soap *soap, const struct ns1__ArrayOfString *a, const char *tag, const char *type)
02282 {
02283 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__ArrayOfString);
02284 if (soap_out_ns1__ArrayOfString(soap, tag, id, a, type))
02285 return soap->error;
02286 return soap_putindependent(soap);
02287 }
02288
02289 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)
02290 {
02291 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__ArrayOfString), type))
02292 return soap->error;
02293 if (a->string)
02294 { int i;
02295 for (i = 0; i < a->__sizestring; i++)
02296 if (soap_out_string(soap, "ns1:string", -1, a->string + i, ""))
02297 return soap->error;
02298 }
02299 return soap_element_end_out(soap, tag);
02300 }
02301
02302 SOAP_FMAC3 struct ns1__ArrayOfString * SOAP_FMAC4 soap_get_ns1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *p, const char *tag, const char *type)
02303 {
02304 if ((p = soap_in_ns1__ArrayOfString(soap, tag, p, type)))
02305 if (soap_getindependent(soap))
02306 return NULL;
02307 return p;
02308 }
02309
02310 SOAP_FMAC3 struct ns1__ArrayOfString * SOAP_FMAC4 soap_in_ns1__ArrayOfString(struct soap *soap, const char *tag, struct ns1__ArrayOfString *a, const char *type)
02311 {
02312 short soap_flag_string = 1;
02313 if (soap_element_begin_in(soap, tag, 0, type))
02314 return NULL;
02315 a = (struct ns1__ArrayOfString *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__ArrayOfString, sizeof(struct ns1__ArrayOfString), 0, NULL, NULL, NULL);
02316 if (!a)
02317 return NULL;
02318 soap_default_ns1__ArrayOfString(soap, a);
02319 if (soap->body && !*soap->href)
02320 {
02321 for (;;)
02322 { soap->error = SOAP_TAG_MISMATCH;
02323 if (soap_flag_string && soap->error == SOAP_TAG_MISMATCH)
02324 { char **p;
02325 soap_new_block(soap);
02326 for (a->__sizestring = 0; !soap_element_begin_in(soap, "ns1:string", 1, NULL); a->__sizestring++)
02327 { p = (char **)soap_push_block(soap,NULL, sizeof(char *));
02328 *p = NULL;
02329 soap_revert(soap);
02330 if (!soap_in_string(soap, "ns1:string", p, "xsd:string"))
02331 break;
02332 soap_flag_string = 0;
02333 }
02334 a->string = (char **)soap_save_block(soap, NULL,NULL, 1);
02335 if (!soap_flag_string && soap->error == SOAP_TAG_MISMATCH)
02336 continue;
02337 }
02338 if (soap->error == SOAP_TAG_MISMATCH)
02339 soap->error = soap_ignore_element(soap);
02340 if (soap->error == SOAP_NO_TAG)
02341 break;
02342 if (soap->error)
02343 return NULL;
02344 }
02345 if (soap_element_end_in(soap, tag))
02346 return NULL;
02347 }
02348 else
02349 { a = (struct ns1__ArrayOfString *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__ArrayOfString, 0, sizeof(struct ns1__ArrayOfString), 0, NULL);
02350 if (soap->body && soap_element_end_in(soap, tag))
02351 return NULL;
02352 }
02353 return a;
02354 }
02355
02356 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__ArrayOfObjInfo(struct soap *soap, struct ns1__ArrayOfObjInfo *a)
02357 {
02358 (void)soap; (void)a;
02359 a->__sizeObjInfo = 0;
02360 a->ObjInfo = NULL;
02361 }
02362
02363 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__ArrayOfObjInfo(struct soap *soap, const struct ns1__ArrayOfObjInfo *a)
02364 {
02365 (void)soap; (void)a;
02366 if (a->ObjInfo)
02367 { int i;
02368 for (i = 0; i < a->__sizeObjInfo; i++)
02369 {
02370 soap_embedded(soap, a->ObjInfo + i, SOAP_TYPE_ns1__ObjInfo);
02371 soap_serialize_ns1__ObjInfo(soap, a->ObjInfo + i);
02372 }
02373 }
02374 }
02375
02376 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__ArrayOfObjInfo(struct soap *soap, const struct ns1__ArrayOfObjInfo *a, const char *tag, const char *type)
02377 {
02378 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__ArrayOfObjInfo);
02379 if (soap_out_ns1__ArrayOfObjInfo(soap, tag, id, a, type))
02380 return soap->error;
02381 return soap_putindependent(soap);
02382 }
02383
02384 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__ArrayOfObjInfo(struct soap *soap, const char *tag, int id, const struct ns1__ArrayOfObjInfo *a, const char *type)
02385 {
02386 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__ArrayOfObjInfo), type))
02387 return soap->error;
02388 if (a->ObjInfo)
02389 { int i;
02390 for (i = 0; i < a->__sizeObjInfo; i++)
02391 if (soap_out_ns1__ObjInfo(soap, "ns1:ObjInfo", -1, a->ObjInfo + i, ""))
02392 return soap->error;
02393 }
02394 return soap_element_end_out(soap, tag);
02395 }
02396
02397 SOAP_FMAC3 struct ns1__ArrayOfObjInfo * SOAP_FMAC4 soap_get_ns1__ArrayOfObjInfo(struct soap *soap, struct ns1__ArrayOfObjInfo *p, const char *tag, const char *type)
02398 {
02399 if ((p = soap_in_ns1__ArrayOfObjInfo(soap, tag, p, type)))
02400 if (soap_getindependent(soap))
02401 return NULL;
02402 return p;
02403 }
02404
02405 SOAP_FMAC3 struct ns1__ArrayOfObjInfo * SOAP_FMAC4 soap_in_ns1__ArrayOfObjInfo(struct soap *soap, const char *tag, struct ns1__ArrayOfObjInfo *a, const char *type)
02406 {
02407 short soap_flag_ObjInfo = 1;
02408 if (soap_element_begin_in(soap, tag, 0, type))
02409 return NULL;
02410 a = (struct ns1__ArrayOfObjInfo *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__ArrayOfObjInfo, sizeof(struct ns1__ArrayOfObjInfo), 0, NULL, NULL, NULL);
02411 if (!a)
02412 return NULL;
02413 soap_default_ns1__ArrayOfObjInfo(soap, a);
02414 if (soap->body && !*soap->href)
02415 {
02416 for (;;)
02417 { soap->error = SOAP_TAG_MISMATCH;
02418 if (soap_flag_ObjInfo && soap->error == SOAP_TAG_MISMATCH)
02419 { struct ns1__ObjInfo *p;
02420 soap_new_block(soap);
02421 for (a->__sizeObjInfo = 0; !soap_element_begin_in(soap, "ns1:ObjInfo", 1, NULL); a->__sizeObjInfo++)
02422 { p = (struct ns1__ObjInfo *)soap_push_block(soap,NULL, sizeof(struct ns1__ObjInfo));
02423 soap_default_ns1__ObjInfo(soap, p);
02424 soap_revert(soap);
02425 if (!soap_in_ns1__ObjInfo(soap, "ns1:ObjInfo", p, "ns1:ObjInfo"))
02426 break;
02427 soap_flag_ObjInfo = 0;
02428 }
02429 a->ObjInfo = (struct ns1__ObjInfo *)soap_save_block(soap, NULL,NULL, 1);
02430 if (!soap_flag_ObjInfo && soap->error == SOAP_TAG_MISMATCH)
02431 continue;
02432 }
02433 if (soap->error == SOAP_TAG_MISMATCH)
02434 soap->error = soap_ignore_element(soap);
02435 if (soap->error == SOAP_NO_TAG)
02436 break;
02437 if (soap->error)
02438 return NULL;
02439 }
02440 if (soap_element_end_in(soap, tag))
02441 return NULL;
02442 }
02443 else
02444 { a = (struct ns1__ArrayOfObjInfo *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__ArrayOfObjInfo, 0, sizeof(struct ns1__ArrayOfObjInfo), 0, NULL);
02445 if (soap->body && soap_element_end_in(soap, tag))
02446 return NULL;
02447 }
02448 return a;
02449 }
02450
02451 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__MoreData(struct soap *soap, struct ns1__MoreData *a)
02452 {
02453 (void)soap; (void)a;
02454 soap_default_string(soap, &a->data_USCOREtypec);
02455 soap_default_string(soap, &a->data);
02456 }
02457
02458 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__MoreData(struct soap *soap, const struct ns1__MoreData *a)
02459 {
02460 (void)soap; (void)a;
02461 soap_serialize_string(soap, &a->data_USCOREtypec);
02462 soap_serialize_string(soap, &a->data);
02463 }
02464
02465 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__MoreData(struct soap *soap, const struct ns1__MoreData *a, const char *tag, const char *type)
02466 {
02467 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__MoreData);
02468 if (soap_out_ns1__MoreData(soap, tag, id, a, type))
02469 return soap->error;
02470 return soap_putindependent(soap);
02471 }
02472
02473 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__MoreData(struct soap *soap, const char *tag, int id, const struct ns1__MoreData *a, const char *type)
02474 {
02475 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__MoreData), type))
02476 return soap->error;
02477 if (soap_out_string(soap, "ns1:data_typec", -1, &a->data_USCOREtypec, ""))
02478 return soap->error;
02479 if (soap_out_string(soap, "ns1:data", -1, &a->data, ""))
02480 return soap->error;
02481 return soap_element_end_out(soap, tag);
02482 }
02483
02484 SOAP_FMAC3 struct ns1__MoreData * SOAP_FMAC4 soap_get_ns1__MoreData(struct soap *soap, struct ns1__MoreData *p, const char *tag, const char *type)
02485 {
02486 if ((p = soap_in_ns1__MoreData(soap, tag, p, type)))
02487 if (soap_getindependent(soap))
02488 return NULL;
02489 return p;
02490 }
02491
02492 SOAP_FMAC3 struct ns1__MoreData * SOAP_FMAC4 soap_in_ns1__MoreData(struct soap *soap, const char *tag, struct ns1__MoreData *a, const char *type)
02493 {
02494 short soap_flag_data_USCOREtypec = 1, soap_flag_data = 1;
02495 if (soap_element_begin_in(soap, tag, 0, type))
02496 return NULL;
02497 a = (struct ns1__MoreData *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__MoreData, sizeof(struct ns1__MoreData), 0, NULL, NULL, NULL);
02498 if (!a)
02499 return NULL;
02500 soap_default_ns1__MoreData(soap, a);
02501 if (soap->body && !*soap->href)
02502 {
02503 for (;;)
02504 { soap->error = SOAP_TAG_MISMATCH;
02505 if (soap_flag_data_USCOREtypec && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02506 if (soap_in_string(soap, "ns1:data_typec", &a->data_USCOREtypec, "xsd:string"))
02507 { soap_flag_data_USCOREtypec--;
02508 continue;
02509 }
02510 if (soap_flag_data && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02511 if (soap_in_string(soap, "ns1:data", &a->data, "xsd:string"))
02512 { soap_flag_data--;
02513 continue;
02514 }
02515 if (soap->error == SOAP_TAG_MISMATCH)
02516 soap->error = soap_ignore_element(soap);
02517 if (soap->error == SOAP_NO_TAG)
02518 break;
02519 if (soap->error)
02520 return NULL;
02521 }
02522 if (soap_element_end_in(soap, tag))
02523 return NULL;
02524 }
02525 else
02526 { a = (struct ns1__MoreData *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__MoreData, 0, sizeof(struct ns1__MoreData), 0, NULL);
02527 if (soap->body && soap_element_end_in(soap, tag))
02528 return NULL;
02529 }
02530 return a;
02531 }
02532
02533 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__CrossID(struct soap *soap, struct ns1__CrossID *a)
02534 {
02535 (void)soap; (void)a;
02536 soap_default_string(soap, &a->objname);
02537 soap_default_string(soap, &a->objtype);
02538 }
02539
02540 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__CrossID(struct soap *soap, const struct ns1__CrossID *a)
02541 {
02542 (void)soap; (void)a;
02543 soap_serialize_string(soap, &a->objname);
02544 soap_serialize_string(soap, &a->objtype);
02545 }
02546
02547 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__CrossID(struct soap *soap, const struct ns1__CrossID *a, const char *tag, const char *type)
02548 {
02549 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__CrossID);
02550 if (soap_out_ns1__CrossID(soap, tag, id, a, type))
02551 return soap->error;
02552 return soap_putindependent(soap);
02553 }
02554
02555 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__CrossID(struct soap *soap, const char *tag, int id, const struct ns1__CrossID *a, const char *type)
02556 {
02557 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__CrossID), type))
02558 return soap->error;
02559 if (soap_out_string(soap, "ns1:objname", -1, &a->objname, ""))
02560 return soap->error;
02561 if (soap_out_string(soap, "ns1:objtype", -1, &a->objtype, ""))
02562 return soap->error;
02563 return soap_element_end_out(soap, tag);
02564 }
02565
02566 SOAP_FMAC3 struct ns1__CrossID * SOAP_FMAC4 soap_get_ns1__CrossID(struct soap *soap, struct ns1__CrossID *p, const char *tag, const char *type)
02567 {
02568 if ((p = soap_in_ns1__CrossID(soap, tag, p, type)))
02569 if (soap_getindependent(soap))
02570 return NULL;
02571 return p;
02572 }
02573
02574 SOAP_FMAC3 struct ns1__CrossID * SOAP_FMAC4 soap_in_ns1__CrossID(struct soap *soap, const char *tag, struct ns1__CrossID *a, const char *type)
02575 {
02576 short soap_flag_objname = 1, soap_flag_objtype = 1;
02577 if (soap_element_begin_in(soap, tag, 0, type))
02578 return NULL;
02579 a = (struct ns1__CrossID *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__CrossID, sizeof(struct ns1__CrossID), 0, NULL, NULL, NULL);
02580 if (!a)
02581 return NULL;
02582 soap_default_ns1__CrossID(soap, a);
02583 if (soap->body && !*soap->href)
02584 {
02585 for (;;)
02586 { soap->error = SOAP_TAG_MISMATCH;
02587 if (soap_flag_objname && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02588 if (soap_in_string(soap, "ns1:objname", &a->objname, "xsd:string"))
02589 { soap_flag_objname--;
02590 continue;
02591 }
02592 if (soap_flag_objtype && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02593 if (soap_in_string(soap, "ns1:objtype", &a->objtype, "xsd:string"))
02594 { soap_flag_objtype--;
02595 continue;
02596 }
02597 if (soap->error == SOAP_TAG_MISMATCH)
02598 soap->error = soap_ignore_element(soap);
02599 if (soap->error == SOAP_NO_TAG)
02600 break;
02601 if (soap->error)
02602 return NULL;
02603 }
02604 if (soap_element_end_in(soap, tag))
02605 return NULL;
02606 }
02607 else
02608 { a = (struct ns1__CrossID *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__CrossID, 0, sizeof(struct ns1__CrossID), 0, NULL);
02609 if (soap->body && soap_element_end_in(soap, tag))
02610 return NULL;
02611 }
02612 return a;
02613 }
02614
02615 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__ArrayOfMoreData(struct soap *soap, struct ns1__ArrayOfMoreData *a)
02616 {
02617 (void)soap; (void)a;
02618 a->__sizeMoreData = 0;
02619 a->MoreData = NULL;
02620 }
02621
02622 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__ArrayOfMoreData(struct soap *soap, const struct ns1__ArrayOfMoreData *a)
02623 {
02624 (void)soap; (void)a;
02625 if (a->MoreData)
02626 { int i;
02627 for (i = 0; i < a->__sizeMoreData; i++)
02628 {
02629 soap_embedded(soap, a->MoreData + i, SOAP_TYPE_ns1__MoreData);
02630 soap_serialize_ns1__MoreData(soap, a->MoreData + i);
02631 }
02632 }
02633 }
02634
02635 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__ArrayOfMoreData(struct soap *soap, const struct ns1__ArrayOfMoreData *a, const char *tag, const char *type)
02636 {
02637 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__ArrayOfMoreData);
02638 if (soap_out_ns1__ArrayOfMoreData(soap, tag, id, a, type))
02639 return soap->error;
02640 return soap_putindependent(soap);
02641 }
02642
02643 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__ArrayOfMoreData(struct soap *soap, const char *tag, int id, const struct ns1__ArrayOfMoreData *a, const char *type)
02644 {
02645 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__ArrayOfMoreData), type))
02646 return soap->error;
02647 if (a->MoreData)
02648 { int i;
02649 for (i = 0; i < a->__sizeMoreData; i++)
02650 if (soap_out_ns1__MoreData(soap, "ns1:MoreData", -1, a->MoreData + i, ""))
02651 return soap->error;
02652 }
02653 return soap_element_end_out(soap, tag);
02654 }
02655
02656 SOAP_FMAC3 struct ns1__ArrayOfMoreData * SOAP_FMAC4 soap_get_ns1__ArrayOfMoreData(struct soap *soap, struct ns1__ArrayOfMoreData *p, const char *tag, const char *type)
02657 {
02658 if ((p = soap_in_ns1__ArrayOfMoreData(soap, tag, p, type)))
02659 if (soap_getindependent(soap))
02660 return NULL;
02661 return p;
02662 }
02663
02664 SOAP_FMAC3 struct ns1__ArrayOfMoreData * SOAP_FMAC4 soap_in_ns1__ArrayOfMoreData(struct soap *soap, const char *tag, struct ns1__ArrayOfMoreData *a, const char *type)
02665 {
02666 short soap_flag_MoreData = 1;
02667 if (soap_element_begin_in(soap, tag, 0, type))
02668 return NULL;
02669 a = (struct ns1__ArrayOfMoreData *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__ArrayOfMoreData, sizeof(struct ns1__ArrayOfMoreData), 0, NULL, NULL, NULL);
02670 if (!a)
02671 return NULL;
02672 soap_default_ns1__ArrayOfMoreData(soap, a);
02673 if (soap->body && !*soap->href)
02674 {
02675 for (;;)
02676 { soap->error = SOAP_TAG_MISMATCH;
02677 if (soap_flag_MoreData && soap->error == SOAP_TAG_MISMATCH)
02678 { struct ns1__MoreData *p;
02679 soap_new_block(soap);
02680 for (a->__sizeMoreData = 0; !soap_element_begin_in(soap, "ns1:MoreData", 1, NULL); a->__sizeMoreData++)
02681 { p = (struct ns1__MoreData *)soap_push_block(soap,NULL, sizeof(struct ns1__MoreData));
02682 soap_default_ns1__MoreData(soap, p);
02683 soap_revert(soap);
02684 if (!soap_in_ns1__MoreData(soap, "ns1:MoreData", p, "ns1:MoreData"))
02685 break;
02686 soap_flag_MoreData = 0;
02687 }
02688 a->MoreData = (struct ns1__MoreData *)soap_save_block(soap, NULL,NULL, 1);
02689 if (!soap_flag_MoreData && soap->error == SOAP_TAG_MISMATCH)
02690 continue;
02691 }
02692 if (soap->error == SOAP_TAG_MISMATCH)
02693 soap->error = soap_ignore_element(soap);
02694 if (soap->error == SOAP_NO_TAG)
02695 break;
02696 if (soap->error)
02697 return NULL;
02698 }
02699 if (soap_element_end_in(soap, tag))
02700 return NULL;
02701 }
02702 else
02703 { a = (struct ns1__ArrayOfMoreData *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__ArrayOfMoreData, 0, sizeof(struct ns1__ArrayOfMoreData), 0, NULL);
02704 if (soap->body && soap_element_end_in(soap, tag))
02705 return NULL;
02706 }
02707 return a;
02708 }
02709
02710 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__ArrayOfCrossID(struct soap *soap, struct ns1__ArrayOfCrossID *a)
02711 {
02712 (void)soap; (void)a;
02713 a->__sizeCrossID = 0;
02714 a->CrossID = NULL;
02715 }
02716
02717 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__ArrayOfCrossID(struct soap *soap, const struct ns1__ArrayOfCrossID *a)
02718 {
02719 (void)soap; (void)a;
02720 if (a->CrossID)
02721 { int i;
02722 for (i = 0; i < a->__sizeCrossID; i++)
02723 {
02724 soap_embedded(soap, a->CrossID + i, SOAP_TYPE_ns1__CrossID);
02725 soap_serialize_ns1__CrossID(soap, a->CrossID + i);
02726 }
02727 }
02728 }
02729
02730 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__ArrayOfCrossID(struct soap *soap, const struct ns1__ArrayOfCrossID *a, const char *tag, const char *type)
02731 {
02732 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__ArrayOfCrossID);
02733 if (soap_out_ns1__ArrayOfCrossID(soap, tag, id, a, type))
02734 return soap->error;
02735 return soap_putindependent(soap);
02736 }
02737
02738 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__ArrayOfCrossID(struct soap *soap, const char *tag, int id, const struct ns1__ArrayOfCrossID *a, const char *type)
02739 {
02740 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__ArrayOfCrossID), type))
02741 return soap->error;
02742 if (a->CrossID)
02743 { int i;
02744 for (i = 0; i < a->__sizeCrossID; i++)
02745 if (soap_out_ns1__CrossID(soap, "ns1:CrossID", -1, a->CrossID + i, ""))
02746 return soap->error;
02747 }
02748 return soap_element_end_out(soap, tag);
02749 }
02750
02751 SOAP_FMAC3 struct ns1__ArrayOfCrossID * SOAP_FMAC4 soap_get_ns1__ArrayOfCrossID(struct soap *soap, struct ns1__ArrayOfCrossID *p, const char *tag, const char *type)
02752 {
02753 if ((p = soap_in_ns1__ArrayOfCrossID(soap, tag, p, type)))
02754 if (soap_getindependent(soap))
02755 return NULL;
02756 return p;
02757 }
02758
02759 SOAP_FMAC3 struct ns1__ArrayOfCrossID * SOAP_FMAC4 soap_in_ns1__ArrayOfCrossID(struct soap *soap, const char *tag, struct ns1__ArrayOfCrossID *a, const char *type)
02760 {
02761 short soap_flag_CrossID = 1;
02762 if (soap_element_begin_in(soap, tag, 0, type))
02763 return NULL;
02764 a = (struct ns1__ArrayOfCrossID *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__ArrayOfCrossID, sizeof(struct ns1__ArrayOfCrossID), 0, NULL, NULL, NULL);
02765 if (!a)
02766 return NULL;
02767 soap_default_ns1__ArrayOfCrossID(soap, a);
02768 if (soap->body && !*soap->href)
02769 {
02770 for (;;)
02771 { soap->error = SOAP_TAG_MISMATCH;
02772 if (soap_flag_CrossID && soap->error == SOAP_TAG_MISMATCH)
02773 { struct ns1__CrossID *p;
02774 soap_new_block(soap);
02775 for (a->__sizeCrossID = 0; !soap_element_begin_in(soap, "ns1:CrossID", 1, NULL); a->__sizeCrossID++)
02776 { p = (struct ns1__CrossID *)soap_push_block(soap,NULL, sizeof(struct ns1__CrossID));
02777 soap_default_ns1__CrossID(soap, p);
02778 soap_revert(soap);
02779 if (!soap_in_ns1__CrossID(soap, "ns1:CrossID", p, "ns1:CrossID"))
02780 break;
02781 soap_flag_CrossID = 0;
02782 }
02783 a->CrossID = (struct ns1__CrossID *)soap_save_block(soap, NULL,NULL, 1);
02784 if (!soap_flag_CrossID && soap->error == SOAP_TAG_MISMATCH)
02785 continue;
02786 }
02787 if (soap->error == SOAP_TAG_MISMATCH)
02788 soap->error = soap_ignore_element(soap);
02789 if (soap->error == SOAP_NO_TAG)
02790 break;
02791 if (soap->error)
02792 return NULL;
02793 }
02794 if (soap_element_end_in(soap, tag))
02795 return NULL;
02796 }
02797 else
02798 { a = (struct ns1__ArrayOfCrossID *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__ArrayOfCrossID, 0, sizeof(struct ns1__ArrayOfCrossID), 0, NULL);
02799 if (soap->body && soap_element_end_in(soap, tag))
02800 return NULL;
02801 }
02802 return a;
02803 }
02804
02805 SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns1__ObjInfo(struct soap *soap, struct ns1__ObjInfo *a)
02806 {
02807 (void)soap; (void)a;
02808 a->ArrayOfCrossID = NULL;
02809 soap_default_double(soap, &a->dist);
02810 soap_default_int(soap, &a->no_USCOREref);
02811 soap_default_int(soap, &a->no_USCOREnote);
02812 soap_default_int(soap, &a->no_USCOREphotom);
02813 soap_default_string(soap, &a->objtype);
02814 soap_default_double(soap, &a->ra);
02815 soap_default_double(soap, &a->dec);
02816 soap_default_double(soap, &a->unc_USCOREmaj);
02817 soap_default_double(soap, &a->unc_USCOREmin);
02818 soap_default_double(soap, &a->unc_USCOREang);
02819 soap_default_string(soap, &a->refcode);
02820 a->ArrayOfMoreData = NULL;
02821 }
02822
02823 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns1__ObjInfo(struct soap *soap, const struct ns1__ObjInfo *a)
02824 {
02825 (void)soap; (void)a;
02826 soap_serialize_PointerTons1__ArrayOfCrossID(soap, &a->ArrayOfCrossID);
02827 soap_serialize_string(soap, &a->objtype);
02828 soap_serialize_string(soap, &a->refcode);
02829 soap_serialize_PointerTons1__ArrayOfMoreData(soap, &a->ArrayOfMoreData);
02830 }
02831
02832 SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns1__ObjInfo(struct soap *soap, const struct ns1__ObjInfo *a, const char *tag, const char *type)
02833 {
02834 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_ns1__ObjInfo);
02835 if (soap_out_ns1__ObjInfo(soap, tag, id, a, type))
02836 return soap->error;
02837 return soap_putindependent(soap);
02838 }
02839
02840 SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns1__ObjInfo(struct soap *soap, const char *tag, int id, const struct ns1__ObjInfo *a, const char *type)
02841 {
02842 if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns1__ObjInfo), type))
02843 return soap->error;
02844 if (soap_out_PointerTons1__ArrayOfCrossID(soap, "ns1:ArrayOfCrossID", -1, &a->ArrayOfCrossID, ""))
02845 return soap->error;
02846 if (soap_out_double(soap, "ns1:dist", -1, &a->dist, ""))
02847 return soap->error;
02848 if (soap_out_int(soap, "ns1:no_ref", -1, &a->no_USCOREref, ""))
02849 return soap->error;
02850 if (soap_out_int(soap, "ns1:no_note", -1, &a->no_USCOREnote, ""))
02851 return soap->error;
02852 if (soap_out_int(soap, "ns1:no_photom", -1, &a->no_USCOREphotom, ""))
02853 return soap->error;
02854 if (soap_out_string(soap, "ns1:objtype", -1, &a->objtype, ""))
02855 return soap->error;
02856 if (soap_out_double(soap, "ns1:ra", -1, &a->ra, ""))
02857 return soap->error;
02858 if (soap_out_double(soap, "ns1:dec", -1, &a->dec, ""))
02859 return soap->error;
02860 if (soap_out_double(soap, "ns1:unc_maj", -1, &a->unc_USCOREmaj, ""))
02861 return soap->error;
02862 if (soap_out_double(soap, "ns1:unc_min", -1, &a->unc_USCOREmin, ""))
02863 return soap->error;
02864 if (soap_out_double(soap, "ns1:unc_ang", -1, &a->unc_USCOREang, ""))
02865 return soap->error;
02866 if (soap_out_string(soap, "ns1:refcode", -1, &a->refcode, ""))
02867 return soap->error;
02868 if (soap_out_PointerTons1__ArrayOfMoreData(soap, "ns1:ArrayOfMoreData", -1, &a->ArrayOfMoreData, ""))
02869 return soap->error;
02870 return soap_element_end_out(soap, tag);
02871 }
02872
02873 SOAP_FMAC3 struct ns1__ObjInfo * SOAP_FMAC4 soap_get_ns1__ObjInfo(struct soap *soap, struct ns1__ObjInfo *p, const char *tag, const char *type)
02874 {
02875 if ((p = soap_in_ns1__ObjInfo(soap, tag, p, type)))
02876 if (soap_getindependent(soap))
02877 return NULL;
02878 return p;
02879 }
02880
02881 SOAP_FMAC3 struct ns1__ObjInfo * SOAP_FMAC4 soap_in_ns1__ObjInfo(struct soap *soap, const char *tag, struct ns1__ObjInfo *a, const char *type)
02882 {
02883 short soap_flag_ArrayOfCrossID = 1, soap_flag_dist = 1, soap_flag_no_USCOREref = 1, soap_flag_no_USCOREnote = 1, soap_flag_no_USCOREphotom = 1, soap_flag_objtype = 1, soap_flag_ra = 1, soap_flag_dec = 1, soap_flag_unc_USCOREmaj = 1, soap_flag_unc_USCOREmin = 1, soap_flag_unc_USCOREang = 1, soap_flag_refcode = 1, soap_flag_ArrayOfMoreData = 1;
02884 if (soap_element_begin_in(soap, tag, 0, type))
02885 return NULL;
02886 a = (struct ns1__ObjInfo *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns1__ObjInfo, sizeof(struct ns1__ObjInfo), 0, NULL, NULL, NULL);
02887 if (!a)
02888 return NULL;
02889 soap_default_ns1__ObjInfo(soap, a);
02890 if (soap->body && !*soap->href)
02891 {
02892 for (;;)
02893 { soap->error = SOAP_TAG_MISMATCH;
02894 if (soap_flag_ArrayOfCrossID && soap->error == SOAP_TAG_MISMATCH)
02895 if (soap_in_PointerTons1__ArrayOfCrossID(soap, "ns1:ArrayOfCrossID", &a->ArrayOfCrossID, "ns1:ArrayOfCrossID"))
02896 { soap_flag_ArrayOfCrossID--;
02897 continue;
02898 }
02899 if (soap_flag_dist && soap->error == SOAP_TAG_MISMATCH)
02900 if (soap_in_double(soap, "ns1:dist", &a->dist, "xsd:double"))
02901 { soap_flag_dist--;
02902 continue;
02903 }
02904 if (soap_flag_no_USCOREref && soap->error == SOAP_TAG_MISMATCH)
02905 if (soap_in_int(soap, "ns1:no_ref", &a->no_USCOREref, "xsd:int"))
02906 { soap_flag_no_USCOREref--;
02907 continue;
02908 }
02909 if (soap_flag_no_USCOREnote && soap->error == SOAP_TAG_MISMATCH)
02910 if (soap_in_int(soap, "ns1:no_note", &a->no_USCOREnote, "xsd:int"))
02911 { soap_flag_no_USCOREnote--;
02912 continue;
02913 }
02914 if (soap_flag_no_USCOREphotom && soap->error == SOAP_TAG_MISMATCH)
02915 if (soap_in_int(soap, "ns1:no_photom", &a->no_USCOREphotom, "xsd:int"))
02916 { soap_flag_no_USCOREphotom--;
02917 continue;
02918 }
02919 if (soap_flag_objtype && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02920 if (soap_in_string(soap, "ns1:objtype", &a->objtype, "xsd:string"))
02921 { soap_flag_objtype--;
02922 continue;
02923 }
02924 if (soap_flag_ra && soap->error == SOAP_TAG_MISMATCH)
02925 if (soap_in_double(soap, "ns1:ra", &a->ra, "xsd:double"))
02926 { soap_flag_ra--;
02927 continue;
02928 }
02929 if (soap_flag_dec && soap->error == SOAP_TAG_MISMATCH)
02930 if (soap_in_double(soap, "ns1:dec", &a->dec, "xsd:double"))
02931 { soap_flag_dec--;
02932 continue;
02933 }
02934 if (soap_flag_unc_USCOREmaj && soap->error == SOAP_TAG_MISMATCH)
02935 if (soap_in_double(soap, "ns1:unc_maj", &a->unc_USCOREmaj, "xsd:double"))
02936 { soap_flag_unc_USCOREmaj--;
02937 continue;
02938 }
02939 if (soap_flag_unc_USCOREmin && soap->error == SOAP_TAG_MISMATCH)
02940 if (soap_in_double(soap, "ns1:unc_min", &a->unc_USCOREmin, "xsd:double"))
02941 { soap_flag_unc_USCOREmin--;
02942 continue;
02943 }
02944 if (soap_flag_unc_USCOREang && soap->error == SOAP_TAG_MISMATCH)
02945 if (soap_in_double(soap, "ns1:unc_ang", &a->unc_USCOREang, "xsd:double"))
02946 { soap_flag_unc_USCOREang--;
02947 continue;
02948 }
02949 if (soap_flag_refcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02950 if (soap_in_string(soap, "ns1:refcode", &a->refcode, "xsd:string"))
02951 { soap_flag_refcode--;
02952 continue;
02953 }
02954 if (soap_flag_ArrayOfMoreData && soap->error == SOAP_TAG_MISMATCH)
02955 if (soap_in_PointerTons1__ArrayOfMoreData(soap, "ns1:ArrayOfMoreData", &a->ArrayOfMoreData, "ns1:ArrayOfMoreData"))
02956 { soap_flag_ArrayOfMoreData--;
02957 continue;
02958 }
02959 if (soap->error == SOAP_TAG_MISMATCH)
02960 soap->error = soap_ignore_element(soap);
02961 if (soap->error == SOAP_NO_TAG)
02962 break;
02963 if (soap->error)
02964 return NULL;
02965 }
02966 if (soap_element_end_in(soap, tag))
02967 return NULL;
02968 }
02969 else
02970 { a = (struct ns1__ObjInfo *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns1__ObjInfo, 0, sizeof(struct ns1__ObjInfo), 0, NULL);
02971 if (soap->body && soap_element_end_in(soap, tag))
02972 return NULL;
02973 }
02974 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_dist > 0 || soap_flag_no_USCOREref > 0 || soap_flag_no_USCOREnote > 0 || soap_flag_no_USCOREphotom > 0 || soap_flag_ra > 0 || soap_flag_dec > 0 || soap_flag_unc_USCOREmaj > 0 || soap_flag_unc_USCOREmin > 0 || soap_flag_unc_USCOREang > 0))
02975 { soap->error = SOAP_OCCURS;
02976 return NULL;
02977 }
02978 return a;
02979 }
02980
02981 #ifndef WITH_NOGLOBAL
02982
02983 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
02984 {
02985 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
02986 soap_serialize_SOAP_ENV__Reason(soap, *a);
02987 }
02988
02989 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)
02990 {
02991 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
02992 if (soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, a, type))
02993 return soap->error;
02994 return soap_putindependent(soap);
02995 }
02996
02997 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)
02998 {
02999 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
03000 if (id < 0)
03001 return soap->error;
03002 return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
03003 }
03004
03005 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)
03006 {
03007 if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
03008 if (soap_getindependent(soap))
03009 return NULL;
03010 return p;
03011 }
03012
03013 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)
03014 {
03015 if (soap_element_begin_in(soap, tag, 1, NULL))
03016 return NULL;
03017 if (!a)
03018 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
03019 return NULL;
03020 *a = NULL;
03021 if (!soap->null && *soap->href != '#')
03022 { soap_revert(soap);
03023 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
03024 return NULL;
03025 }
03026 else
03027 { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
03028 if (soap->body && soap_element_end_in(soap, tag))
03029 return NULL;
03030 }
03031 return a;
03032 }
03033
03034 #endif
03035
03036 #ifndef WITH_NOGLOBAL
03037
03038 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
03039 {
03040 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
03041 soap_serialize_SOAP_ENV__Detail(soap, *a);
03042 }
03043
03044 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)
03045 {
03046 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
03047 if (soap_out_PointerToSOAP_ENV__Detail(soap, tag, id, a, type))
03048 return soap->error;
03049 return soap_putindependent(soap);
03050 }
03051
03052 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)
03053 {
03054 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
03055 if (id < 0)
03056 return soap->error;
03057 return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
03058 }
03059
03060 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)
03061 {
03062 if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
03063 if (soap_getindependent(soap))
03064 return NULL;
03065 return p;
03066 }
03067
03068 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)
03069 {
03070 if (soap_element_begin_in(soap, tag, 1, NULL))
03071 return NULL;
03072 if (!a)
03073 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
03074 return NULL;
03075 *a = NULL;
03076 if (!soap->null && *soap->href != '#')
03077 { soap_revert(soap);
03078 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
03079 return NULL;
03080 }
03081 else
03082 { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
03083 if (soap->body && soap_element_end_in(soap, tag))
03084 return NULL;
03085 }
03086 return a;
03087 }
03088
03089 #endif
03090
03091 #ifndef WITH_NOGLOBAL
03092
03093 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
03094 {
03095 if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
03096 soap_serialize_SOAP_ENV__Code(soap, *a);
03097 }
03098
03099 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)
03100 {
03101 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
03102 if (soap_out_PointerToSOAP_ENV__Code(soap, tag, id, a, type))
03103 return soap->error;
03104 return soap_putindependent(soap);
03105 }
03106
03107 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)
03108 {
03109 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
03110 if (id < 0)
03111 return soap->error;
03112 return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
03113 }
03114
03115 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)
03116 {
03117 if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
03118 if (soap_getindependent(soap))
03119 return NULL;
03120 return p;
03121 }
03122
03123 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)
03124 {
03125 if (soap_element_begin_in(soap, tag, 1, NULL))
03126 return NULL;
03127 if (!a)
03128 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
03129 return NULL;
03130 *a = NULL;
03131 if (!soap->null && *soap->href != '#')
03132 { soap_revert(soap);
03133 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
03134 return NULL;
03135 }
03136 else
03137 { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
03138 if (soap->body && soap_element_end_in(soap, tag))
03139 return NULL;
03140 }
03141 return a;
03142 }
03143
03144 #endif
03145
03146 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *const*a)
03147 {
03148 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__RevisionsResponse))
03149 soap_serialize__ns1__RevisionsResponse(soap, *a);
03150 }
03151
03152 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__RevisionsResponse(struct soap *soap, struct _ns1__RevisionsResponse *const*a, const char *tag, const char *type)
03153 {
03154 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__RevisionsResponse);
03155 if (soap_out_PointerTo_ns1__RevisionsResponse(soap, tag, id, a, type))
03156 return soap->error;
03157 return soap_putindependent(soap);
03158 }
03159
03160 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)
03161 {
03162 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__RevisionsResponse);
03163 if (id < 0)
03164 return soap->error;
03165 return soap_out__ns1__RevisionsResponse(soap, tag, id, *a, type);
03166 }
03167
03168 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)
03169 {
03170 if ((p = soap_in_PointerTo_ns1__RevisionsResponse(soap, tag, p, type)))
03171 if (soap_getindependent(soap))
03172 return NULL;
03173 return p;
03174 }
03175
03176 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)
03177 {
03178 if (soap_element_begin_in(soap, tag, 1, NULL))
03179 return NULL;
03180 if (!a)
03181 if (!(a = (struct _ns1__RevisionsResponse **)soap_malloc(soap, sizeof(struct _ns1__RevisionsResponse *))))
03182 return NULL;
03183 *a = NULL;
03184 if (!soap->null && *soap->href != '#')
03185 { soap_revert(soap);
03186 if (!(*a = soap_in__ns1__RevisionsResponse(soap, tag, *a, type)))
03187 return NULL;
03188 }
03189 else
03190 { a = (struct _ns1__RevisionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__RevisionsResponse, sizeof(struct _ns1__RevisionsResponse), 0);
03191 if (soap->body && soap_element_end_in(soap, tag))
03192 return NULL;
03193 }
03194 return a;
03195 }
03196
03197 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__Revisions(struct soap *soap, struct _ns1__Revisions *const*a)
03198 {
03199 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__Revisions))
03200 soap_serialize__ns1__Revisions(soap, *a);
03201 }
03202
03203 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__Revisions(struct soap *soap, struct _ns1__Revisions *const*a, const char *tag, const char *type)
03204 {
03205 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__Revisions);
03206 if (soap_out_PointerTo_ns1__Revisions(soap, tag, id, a, type))
03207 return soap->error;
03208 return soap_putindependent(soap);
03209 }
03210
03211 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)
03212 {
03213 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__Revisions);
03214 if (id < 0)
03215 return soap->error;
03216 return soap_out__ns1__Revisions(soap, tag, id, *a, type);
03217 }
03218
03219 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)
03220 {
03221 if ((p = soap_in_PointerTo_ns1__Revisions(soap, tag, p, type)))
03222 if (soap_getindependent(soap))
03223 return NULL;
03224 return p;
03225 }
03226
03227 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)
03228 {
03229 if (soap_element_begin_in(soap, tag, 1, NULL))
03230 return NULL;
03231 if (!a)
03232 if (!(a = (struct _ns1__Revisions **)soap_malloc(soap, sizeof(struct _ns1__Revisions *))))
03233 return NULL;
03234 *a = NULL;
03235 if (!soap->null && *soap->href != '#')
03236 { soap_revert(soap);
03237 if (!(*a = soap_in__ns1__Revisions(soap, tag, *a, type)))
03238 return NULL;
03239 }
03240 else
03241 { a = (struct _ns1__Revisions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__Revisions, sizeof(struct _ns1__Revisions), 0);
03242 if (soap->body && soap_element_end_in(soap, tag))
03243 return NULL;
03244 }
03245 return a;
03246 }
03247
03248 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ObjNearPosnResponse(struct soap *soap, struct _ns1__ObjNearPosnResponse *const*a)
03249 {
03250 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ObjNearPosnResponse))
03251 soap_serialize__ns1__ObjNearPosnResponse(soap, *a);
03252 }
03253
03254 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ObjNearPosnResponse(struct soap *soap, struct _ns1__ObjNearPosnResponse *const*a, const char *tag, const char *type)
03255 {
03256 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ObjNearPosnResponse);
03257 if (soap_out_PointerTo_ns1__ObjNearPosnResponse(soap, tag, id, a, type))
03258 return soap->error;
03259 return soap_putindependent(soap);
03260 }
03261
03262 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ObjNearPosnResponse(struct soap *soap, const char *tag, int id, struct _ns1__ObjNearPosnResponse *const*a, const char *type)
03263 {
03264 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ObjNearPosnResponse);
03265 if (id < 0)
03266 return soap->error;
03267 return soap_out__ns1__ObjNearPosnResponse(soap, tag, id, *a, type);
03268 }
03269
03270 SOAP_FMAC3 struct _ns1__ObjNearPosnResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__ObjNearPosnResponse(struct soap *soap, struct _ns1__ObjNearPosnResponse **p, const char *tag, const char *type)
03271 {
03272 if ((p = soap_in_PointerTo_ns1__ObjNearPosnResponse(soap, tag, p, type)))
03273 if (soap_getindependent(soap))
03274 return NULL;
03275 return p;
03276 }
03277
03278 SOAP_FMAC3 struct _ns1__ObjNearPosnResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__ObjNearPosnResponse(struct soap *soap, const char *tag, struct _ns1__ObjNearPosnResponse **a, const char *type)
03279 {
03280 if (soap_element_begin_in(soap, tag, 1, NULL))
03281 return NULL;
03282 if (!a)
03283 if (!(a = (struct _ns1__ObjNearPosnResponse **)soap_malloc(soap, sizeof(struct _ns1__ObjNearPosnResponse *))))
03284 return NULL;
03285 *a = NULL;
03286 if (!soap->null && *soap->href != '#')
03287 { soap_revert(soap);
03288 if (!(*a = soap_in__ns1__ObjNearPosnResponse(soap, tag, *a, type)))
03289 return NULL;
03290 }
03291 else
03292 { a = (struct _ns1__ObjNearPosnResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ObjNearPosnResponse, sizeof(struct _ns1__ObjNearPosnResponse), 0);
03293 if (soap->body && soap_element_end_in(soap, tag))
03294 return NULL;
03295 }
03296 return a;
03297 }
03298
03299 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ObjNearPosn(struct soap *soap, struct _ns1__ObjNearPosn *const*a)
03300 {
03301 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ObjNearPosn))
03302 soap_serialize__ns1__ObjNearPosn(soap, *a);
03303 }
03304
03305 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ObjNearPosn(struct soap *soap, struct _ns1__ObjNearPosn *const*a, const char *tag, const char *type)
03306 {
03307 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ObjNearPosn);
03308 if (soap_out_PointerTo_ns1__ObjNearPosn(soap, tag, id, a, type))
03309 return soap->error;
03310 return soap_putindependent(soap);
03311 }
03312
03313 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ObjNearPosn(struct soap *soap, const char *tag, int id, struct _ns1__ObjNearPosn *const*a, const char *type)
03314 {
03315 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ObjNearPosn);
03316 if (id < 0)
03317 return soap->error;
03318 return soap_out__ns1__ObjNearPosn(soap, tag, id, *a, type);
03319 }
03320
03321 SOAP_FMAC3 struct _ns1__ObjNearPosn ** SOAP_FMAC4 soap_get_PointerTo_ns1__ObjNearPosn(struct soap *soap, struct _ns1__ObjNearPosn **p, const char *tag, const char *type)
03322 {
03323 if ((p = soap_in_PointerTo_ns1__ObjNearPosn(soap, tag, p, type)))
03324 if (soap_getindependent(soap))
03325 return NULL;
03326 return p;
03327 }
03328
03329 SOAP_FMAC3 struct _ns1__ObjNearPosn ** SOAP_FMAC4 soap_in_PointerTo_ns1__ObjNearPosn(struct soap *soap, const char *tag, struct _ns1__ObjNearPosn **a, const char *type)
03330 {
03331 if (soap_element_begin_in(soap, tag, 1, NULL))
03332 return NULL;
03333 if (!a)
03334 if (!(a = (struct _ns1__ObjNearPosn **)soap_malloc(soap, sizeof(struct _ns1__ObjNearPosn *))))
03335 return NULL;
03336 *a = NULL;
03337 if (!soap->null && *soap->href != '#')
03338 { soap_revert(soap);
03339 if (!(*a = soap_in__ns1__ObjNearPosn(soap, tag, *a, type)))
03340 return NULL;
03341 }
03342 else
03343 { a = (struct _ns1__ObjNearPosn **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ObjNearPosn, sizeof(struct _ns1__ObjNearPosn), 0);
03344 if (soap->body && soap_element_end_in(soap, tag))
03345 return NULL;
03346 }
03347 return a;
03348 }
03349
03350 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ObjNearNameResponse(struct soap *soap, struct _ns1__ObjNearNameResponse *const*a)
03351 {
03352 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ObjNearNameResponse))
03353 soap_serialize__ns1__ObjNearNameResponse(soap, *a);
03354 }
03355
03356 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ObjNearNameResponse(struct soap *soap, struct _ns1__ObjNearNameResponse *const*a, const char *tag, const char *type)
03357 {
03358 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ObjNearNameResponse);
03359 if (soap_out_PointerTo_ns1__ObjNearNameResponse(soap, tag, id, a, type))
03360 return soap->error;
03361 return soap_putindependent(soap);
03362 }
03363
03364 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ObjNearNameResponse(struct soap *soap, const char *tag, int id, struct _ns1__ObjNearNameResponse *const*a, const char *type)
03365 {
03366 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ObjNearNameResponse);
03367 if (id < 0)
03368 return soap->error;
03369 return soap_out__ns1__ObjNearNameResponse(soap, tag, id, *a, type);
03370 }
03371
03372 SOAP_FMAC3 struct _ns1__ObjNearNameResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__ObjNearNameResponse(struct soap *soap, struct _ns1__ObjNearNameResponse **p, const char *tag, const char *type)
03373 {
03374 if ((p = soap_in_PointerTo_ns1__ObjNearNameResponse(soap, tag, p, type)))
03375 if (soap_getindependent(soap))
03376 return NULL;
03377 return p;
03378 }
03379
03380 SOAP_FMAC3 struct _ns1__ObjNearNameResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__ObjNearNameResponse(struct soap *soap, const char *tag, struct _ns1__ObjNearNameResponse **a, const char *type)
03381 {
03382 if (soap_element_begin_in(soap, tag, 1, NULL))
03383 return NULL;
03384 if (!a)
03385 if (!(a = (struct _ns1__ObjNearNameResponse **)soap_malloc(soap, sizeof(struct _ns1__ObjNearNameResponse *))))
03386 return NULL;
03387 *a = NULL;
03388 if (!soap->null && *soap->href != '#')
03389 { soap_revert(soap);
03390 if (!(*a = soap_in__ns1__ObjNearNameResponse(soap, tag, *a, type)))
03391 return NULL;
03392 }
03393 else
03394 { a = (struct _ns1__ObjNearNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ObjNearNameResponse, sizeof(struct _ns1__ObjNearNameResponse), 0);
03395 if (soap->body && soap_element_end_in(soap, tag))
03396 return NULL;
03397 }
03398 return a;
03399 }
03400
03401 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ObjNearName(struct soap *soap, struct _ns1__ObjNearName *const*a)
03402 {
03403 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ObjNearName))
03404 soap_serialize__ns1__ObjNearName(soap, *a);
03405 }
03406
03407 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ObjNearName(struct soap *soap, struct _ns1__ObjNearName *const*a, const char *tag, const char *type)
03408 {
03409 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ObjNearName);
03410 if (soap_out_PointerTo_ns1__ObjNearName(soap, tag, id, a, type))
03411 return soap->error;
03412 return soap_putindependent(soap);
03413 }
03414
03415 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ObjNearName(struct soap *soap, const char *tag, int id, struct _ns1__ObjNearName *const*a, const char *type)
03416 {
03417 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ObjNearName);
03418 if (id < 0)
03419 return soap->error;
03420 return soap_out__ns1__ObjNearName(soap, tag, id, *a, type);
03421 }
03422
03423 SOAP_FMAC3 struct _ns1__ObjNearName ** SOAP_FMAC4 soap_get_PointerTo_ns1__ObjNearName(struct soap *soap, struct _ns1__ObjNearName **p, const char *tag, const char *type)
03424 {
03425 if ((p = soap_in_PointerTo_ns1__ObjNearName(soap, tag, p, type)))
03426 if (soap_getindependent(soap))
03427 return NULL;
03428 return p;
03429 }
03430
03431 SOAP_FMAC3 struct _ns1__ObjNearName ** SOAP_FMAC4 soap_in_PointerTo_ns1__ObjNearName(struct soap *soap, const char *tag, struct _ns1__ObjNearName **a, const char *type)
03432 {
03433 if (soap_element_begin_in(soap, tag, 1, NULL))
03434 return NULL;
03435 if (!a)
03436 if (!(a = (struct _ns1__ObjNearName **)soap_malloc(soap, sizeof(struct _ns1__ObjNearName *))))
03437 return NULL;
03438 *a = NULL;
03439 if (!soap->null && *soap->href != '#')
03440 { soap_revert(soap);
03441 if (!(*a = soap_in__ns1__ObjNearName(soap, tag, *a, type)))
03442 return NULL;
03443 }
03444 else
03445 { a = (struct _ns1__ObjNearName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ObjNearName, sizeof(struct _ns1__ObjNearName), 0);
03446 if (soap->body && soap_element_end_in(soap, tag))
03447 return NULL;
03448 }
03449 return a;
03450 }
03451
03452 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ObjByNameResponse(struct soap *soap, struct _ns1__ObjByNameResponse *const*a)
03453 {
03454 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ObjByNameResponse))
03455 soap_serialize__ns1__ObjByNameResponse(soap, *a);
03456 }
03457
03458 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ObjByNameResponse(struct soap *soap, struct _ns1__ObjByNameResponse *const*a, const char *tag, const char *type)
03459 {
03460 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ObjByNameResponse);
03461 if (soap_out_PointerTo_ns1__ObjByNameResponse(soap, tag, id, a, type))
03462 return soap->error;
03463 return soap_putindependent(soap);
03464 }
03465
03466 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ObjByNameResponse(struct soap *soap, const char *tag, int id, struct _ns1__ObjByNameResponse *const*a, const char *type)
03467 {
03468 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ObjByNameResponse);
03469 if (id < 0)
03470 return soap->error;
03471 return soap_out__ns1__ObjByNameResponse(soap, tag, id, *a, type);
03472 }
03473
03474 SOAP_FMAC3 struct _ns1__ObjByNameResponse ** SOAP_FMAC4 soap_get_PointerTo_ns1__ObjByNameResponse(struct soap *soap, struct _ns1__ObjByNameResponse **p, const char *tag, const char *type)
03475 {
03476 if ((p = soap_in_PointerTo_ns1__ObjByNameResponse(soap, tag, p, type)))
03477 if (soap_getindependent(soap))
03478 return NULL;
03479 return p;
03480 }
03481
03482 SOAP_FMAC3 struct _ns1__ObjByNameResponse ** SOAP_FMAC4 soap_in_PointerTo_ns1__ObjByNameResponse(struct soap *soap, const char *tag, struct _ns1__ObjByNameResponse **a, const char *type)
03483 {
03484 if (soap_element_begin_in(soap, tag, 1, NULL))
03485 return NULL;
03486 if (!a)
03487 if (!(a = (struct _ns1__ObjByNameResponse **)soap_malloc(soap, sizeof(struct _ns1__ObjByNameResponse *))))
03488 return NULL;
03489 *a = NULL;
03490 if (!soap->null && *soap->href != '#')
03491 { soap_revert(soap);
03492 if (!(*a = soap_in__ns1__ObjByNameResponse(soap, tag, *a, type)))
03493 return NULL;
03494 }
03495 else
03496 { a = (struct _ns1__ObjByNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ObjByNameResponse, sizeof(struct _ns1__ObjByNameResponse), 0);
03497 if (soap->body && soap_element_end_in(soap, tag))
03498 return NULL;
03499 }
03500 return a;
03501 }
03502
03503 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_ns1__ObjByName(struct soap *soap, struct _ns1__ObjByName *const*a)
03504 {
03505 if (!soap_reference(soap, *a, SOAP_TYPE__ns1__ObjByName))
03506 soap_serialize__ns1__ObjByName(soap, *a);
03507 }
03508
03509 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_ns1__ObjByName(struct soap *soap, struct _ns1__ObjByName *const*a, const char *tag, const char *type)
03510 {
03511 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_ns1__ObjByName);
03512 if (soap_out_PointerTo_ns1__ObjByName(soap, tag, id, a, type))
03513 return soap->error;
03514 return soap_putindependent(soap);
03515 }
03516
03517 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_ns1__ObjByName(struct soap *soap, const char *tag, int id, struct _ns1__ObjByName *const*a, const char *type)
03518 {
03519 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__ns1__ObjByName);
03520 if (id < 0)
03521 return soap->error;
03522 return soap_out__ns1__ObjByName(soap, tag, id, *a, type);
03523 }
03524
03525 SOAP_FMAC3 struct _ns1__ObjByName ** SOAP_FMAC4 soap_get_PointerTo_ns1__ObjByName(struct soap *soap, struct _ns1__ObjByName **p, const char *tag, const char *type)
03526 {
03527 if ((p = soap_in_PointerTo_ns1__ObjByName(soap, tag, p, type)))
03528 if (soap_getindependent(soap))
03529 return NULL;
03530 return p;
03531 }
03532
03533 SOAP_FMAC3 struct _ns1__ObjByName ** SOAP_FMAC4 soap_in_PointerTo_ns1__ObjByName(struct soap *soap, const char *tag, struct _ns1__ObjByName **a, const char *type)
03534 {
03535 if (soap_element_begin_in(soap, tag, 1, NULL))
03536 return NULL;
03537 if (!a)
03538 if (!(a = (struct _ns1__ObjByName **)soap_malloc(soap, sizeof(struct _ns1__ObjByName *))))
03539 return NULL;
03540 *a = NULL;
03541 if (!soap->null && *soap->href != '#')
03542 { soap_revert(soap);
03543 if (!(*a = soap_in__ns1__ObjByName(soap, tag, *a, type)))
03544 return NULL;
03545 }
03546 else
03547 { a = (struct _ns1__ObjByName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__ns1__ObjByName, sizeof(struct _ns1__ObjByName), 0);
03548 if (soap->body && soap_element_end_in(soap, tag))
03549 return NULL;
03550 }
03551 return a;
03552 }
03553
03554 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *const*a)
03555 {
03556 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__ArrayOfString))
03557 soap_serialize_ns1__ArrayOfString(soap, *a);
03558 }
03559
03560 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString *const*a, const char *tag, const char *type)
03561 {
03562 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__ArrayOfString);
03563 if (soap_out_PointerTons1__ArrayOfString(soap, tag, id, a, type))
03564 return soap->error;
03565 return soap_putindependent(soap);
03566 }
03567
03568 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)
03569 {
03570 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__ArrayOfString);
03571 if (id < 0)
03572 return soap->error;
03573 return soap_out_ns1__ArrayOfString(soap, tag, id, *a, type);
03574 }
03575
03576 SOAP_FMAC3 struct ns1__ArrayOfString ** SOAP_FMAC4 soap_get_PointerTons1__ArrayOfString(struct soap *soap, struct ns1__ArrayOfString **p, const char *tag, const char *type)
03577 {
03578 if ((p = soap_in_PointerTons1__ArrayOfString(soap, tag, p, type)))
03579 if (soap_getindependent(soap))
03580 return NULL;
03581 return p;
03582 }
03583
03584 SOAP_FMAC3 struct ns1__ArrayOfString ** SOAP_FMAC4 soap_in_PointerTons1__ArrayOfString(struct soap *soap, const char *tag, struct ns1__ArrayOfString **a, const char *type)
03585 {
03586 if (soap_element_begin_in(soap, tag, 1, NULL))
03587 return NULL;
03588 if (!a)
03589 if (!(a = (struct ns1__ArrayOfString **)soap_malloc(soap, sizeof(struct ns1__ArrayOfString *))))
03590 return NULL;
03591 *a = NULL;
03592 if (!soap->null && *soap->href != '#')
03593 { soap_revert(soap);
03594 if (!(*a = soap_in_ns1__ArrayOfString(soap, tag, *a, type)))
03595 return NULL;
03596 }
03597 else
03598 { a = (struct ns1__ArrayOfString **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__ArrayOfString, sizeof(struct ns1__ArrayOfString), 0);
03599 if (soap->body && soap_element_end_in(soap, tag))
03600 return NULL;
03601 }
03602 return a;
03603 }
03604
03605 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__ArrayOfObjInfo(struct soap *soap, struct ns1__ArrayOfObjInfo *const*a)
03606 {
03607 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__ArrayOfObjInfo))
03608 soap_serialize_ns1__ArrayOfObjInfo(soap, *a);
03609 }
03610
03611 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__ArrayOfObjInfo(struct soap *soap, struct ns1__ArrayOfObjInfo *const*a, const char *tag, const char *type)
03612 {
03613 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__ArrayOfObjInfo);
03614 if (soap_out_PointerTons1__ArrayOfObjInfo(soap, tag, id, a, type))
03615 return soap->error;
03616 return soap_putindependent(soap);
03617 }
03618
03619 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__ArrayOfObjInfo(struct soap *soap, const char *tag, int id, struct ns1__ArrayOfObjInfo *const*a, const char *type)
03620 {
03621 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__ArrayOfObjInfo);
03622 if (id < 0)
03623 return soap->error;
03624 return soap_out_ns1__ArrayOfObjInfo(soap, tag, id, *a, type);
03625 }
03626
03627 SOAP_FMAC3 struct ns1__ArrayOfObjInfo ** SOAP_FMAC4 soap_get_PointerTons1__ArrayOfObjInfo(struct soap *soap, struct ns1__ArrayOfObjInfo **p, const char *tag, const char *type)
03628 {
03629 if ((p = soap_in_PointerTons1__ArrayOfObjInfo(soap, tag, p, type)))
03630 if (soap_getindependent(soap))
03631 return NULL;
03632 return p;
03633 }
03634
03635 SOAP_FMAC3 struct ns1__ArrayOfObjInfo ** SOAP_FMAC4 soap_in_PointerTons1__ArrayOfObjInfo(struct soap *soap, const char *tag, struct ns1__ArrayOfObjInfo **a, const char *type)
03636 {
03637 if (soap_element_begin_in(soap, tag, 1, NULL))
03638 return NULL;
03639 if (!a)
03640 if (!(a = (struct ns1__ArrayOfObjInfo **)soap_malloc(soap, sizeof(struct ns1__ArrayOfObjInfo *))))
03641 return NULL;
03642 *a = NULL;
03643 if (!soap->null && *soap->href != '#')
03644 { soap_revert(soap);
03645 if (!(*a = soap_in_ns1__ArrayOfObjInfo(soap, tag, *a, type)))
03646 return NULL;
03647 }
03648 else
03649 { a = (struct ns1__ArrayOfObjInfo **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__ArrayOfObjInfo, sizeof(struct ns1__ArrayOfObjInfo), 0);
03650 if (soap->body && soap_element_end_in(soap, tag))
03651 return NULL;
03652 }
03653 return a;
03654 }
03655
03656 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostring(struct soap *soap, char **const*a)
03657 {
03658 if (!soap_reference(soap, *a, SOAP_TYPE_string))
03659 soap_serialize_string(soap, *a);
03660 }
03661
03662 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostring(struct soap *soap, char **const*a, const char *tag, const char *type)
03663 {
03664 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostring);
03665 if (soap_out_PointerTostring(soap, tag, id, a, type))
03666 return soap->error;
03667 return soap_putindependent(soap);
03668 }
03669
03670 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostring(struct soap *soap, const char *tag, int id, char **const*a, const char *type)
03671 {
03672 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_string);
03673 if (id < 0)
03674 return soap->error;
03675 return soap_out_string(soap, tag, id, *a, type);
03676 }
03677
03678 SOAP_FMAC3 char *** SOAP_FMAC4 soap_get_PointerTostring(struct soap *soap, char ***p, const char *tag, const char *type)
03679 {
03680 if ((p = soap_in_PointerTostring(soap, tag, p, type)))
03681 if (soap_getindependent(soap))
03682 return NULL;
03683 return p;
03684 }
03685
03686 SOAP_FMAC3 char *** SOAP_FMAC4 soap_in_PointerTostring(struct soap *soap, const char *tag, char ***a, const char *type)
03687 {
03688 if (soap_element_begin_in(soap, tag, 1, NULL))
03689 return NULL;
03690 if (!a)
03691 if (!(a = (char ***)soap_malloc(soap, sizeof(char **))))
03692 return NULL;
03693 *a = NULL;
03694 if (!soap->null && *soap->href != '#')
03695 { soap_revert(soap);
03696 if (!(*a = soap_in_string(soap, tag, *a, type)))
03697 return NULL;
03698 }
03699 else
03700 { a = (char ***)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_string, sizeof(char *), 1);
03701 if (soap->body && soap_element_end_in(soap, tag))
03702 return NULL;
03703 }
03704 return a;
03705 }
03706
03707 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__ObjInfo(struct soap *soap, struct ns1__ObjInfo *const*a)
03708 {
03709 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__ObjInfo))
03710 soap_serialize_ns1__ObjInfo(soap, *a);
03711 }
03712
03713 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__ObjInfo(struct soap *soap, struct ns1__ObjInfo *const*a, const char *tag, const char *type)
03714 {
03715 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__ObjInfo);
03716 if (soap_out_PointerTons1__ObjInfo(soap, tag, id, a, type))
03717 return soap->error;
03718 return soap_putindependent(soap);
03719 }
03720
03721 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__ObjInfo(struct soap *soap, const char *tag, int id, struct ns1__ObjInfo *const*a, const char *type)
03722 {
03723 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__ObjInfo);
03724 if (id < 0)
03725 return soap->error;
03726 return soap_out_ns1__ObjInfo(soap, tag, id, *a, type);
03727 }
03728
03729 SOAP_FMAC3 struct ns1__ObjInfo ** SOAP_FMAC4 soap_get_PointerTons1__ObjInfo(struct soap *soap, struct ns1__ObjInfo **p, const char *tag, const char *type)
03730 {
03731 if ((p = soap_in_PointerTons1__ObjInfo(soap, tag, p, type)))
03732 if (soap_getindependent(soap))
03733 return NULL;
03734 return p;
03735 }
03736
03737 SOAP_FMAC3 struct ns1__ObjInfo ** SOAP_FMAC4 soap_in_PointerTons1__ObjInfo(struct soap *soap, const char *tag, struct ns1__ObjInfo **a, const char *type)
03738 {
03739 if (soap_element_begin_in(soap, tag, 1, NULL))
03740 return NULL;
03741 if (!a)
03742 if (!(a = (struct ns1__ObjInfo **)soap_malloc(soap, sizeof(struct ns1__ObjInfo *))))
03743 return NULL;
03744 *a = NULL;
03745 if (!soap->null && *soap->href != '#')
03746 { soap_revert(soap);
03747 if (!(*a = soap_in_ns1__ObjInfo(soap, tag, *a, type)))
03748 return NULL;
03749 }
03750 else
03751 { a = (struct ns1__ObjInfo **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__ObjInfo, sizeof(struct ns1__ObjInfo), 0);
03752 if (soap->body && soap_element_end_in(soap, tag))
03753 return NULL;
03754 }
03755 return a;
03756 }
03757
03758 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__MoreData(struct soap *soap, struct ns1__MoreData *const*a)
03759 {
03760 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__MoreData))
03761 soap_serialize_ns1__MoreData(soap, *a);
03762 }
03763
03764 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__MoreData(struct soap *soap, struct ns1__MoreData *const*a, const char *tag, const char *type)
03765 {
03766 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__MoreData);
03767 if (soap_out_PointerTons1__MoreData(soap, tag, id, a, type))
03768 return soap->error;
03769 return soap_putindependent(soap);
03770 }
03771
03772 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__MoreData(struct soap *soap, const char *tag, int id, struct ns1__MoreData *const*a, const char *type)
03773 {
03774 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__MoreData);
03775 if (id < 0)
03776 return soap->error;
03777 return soap_out_ns1__MoreData(soap, tag, id, *a, type);
03778 }
03779
03780 SOAP_FMAC3 struct ns1__MoreData ** SOAP_FMAC4 soap_get_PointerTons1__MoreData(struct soap *soap, struct ns1__MoreData **p, const char *tag, const char *type)
03781 {
03782 if ((p = soap_in_PointerTons1__MoreData(soap, tag, p, type)))
03783 if (soap_getindependent(soap))
03784 return NULL;
03785 return p;
03786 }
03787
03788 SOAP_FMAC3 struct ns1__MoreData ** SOAP_FMAC4 soap_in_PointerTons1__MoreData(struct soap *soap, const char *tag, struct ns1__MoreData **a, const char *type)
03789 {
03790 if (soap_element_begin_in(soap, tag, 1, NULL))
03791 return NULL;
03792 if (!a)
03793 if (!(a = (struct ns1__MoreData **)soap_malloc(soap, sizeof(struct ns1__MoreData *))))
03794 return NULL;
03795 *a = NULL;
03796 if (!soap->null && *soap->href != '#')
03797 { soap_revert(soap);
03798 if (!(*a = soap_in_ns1__MoreData(soap, tag, *a, type)))
03799 return NULL;
03800 }
03801 else
03802 { a = (struct ns1__MoreData **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__MoreData, sizeof(struct ns1__MoreData), 0);
03803 if (soap->body && soap_element_end_in(soap, tag))
03804 return NULL;
03805 }
03806 return a;
03807 }
03808
03809 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__CrossID(struct soap *soap, struct ns1__CrossID *const*a)
03810 {
03811 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__CrossID))
03812 soap_serialize_ns1__CrossID(soap, *a);
03813 }
03814
03815 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__CrossID(struct soap *soap, struct ns1__CrossID *const*a, const char *tag, const char *type)
03816 {
03817 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__CrossID);
03818 if (soap_out_PointerTons1__CrossID(soap, tag, id, a, type))
03819 return soap->error;
03820 return soap_putindependent(soap);
03821 }
03822
03823 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__CrossID(struct soap *soap, const char *tag, int id, struct ns1__CrossID *const*a, const char *type)
03824 {
03825 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__CrossID);
03826 if (id < 0)
03827 return soap->error;
03828 return soap_out_ns1__CrossID(soap, tag, id, *a, type);
03829 }
03830
03831 SOAP_FMAC3 struct ns1__CrossID ** SOAP_FMAC4 soap_get_PointerTons1__CrossID(struct soap *soap, struct ns1__CrossID **p, const char *tag, const char *type)
03832 {
03833 if ((p = soap_in_PointerTons1__CrossID(soap, tag, p, type)))
03834 if (soap_getindependent(soap))
03835 return NULL;
03836 return p;
03837 }
03838
03839 SOAP_FMAC3 struct ns1__CrossID ** SOAP_FMAC4 soap_in_PointerTons1__CrossID(struct soap *soap, const char *tag, struct ns1__CrossID **a, const char *type)
03840 {
03841 if (soap_element_begin_in(soap, tag, 1, NULL))
03842 return NULL;
03843 if (!a)
03844 if (!(a = (struct ns1__CrossID **)soap_malloc(soap, sizeof(struct ns1__CrossID *))))
03845 return NULL;
03846 *a = NULL;
03847 if (!soap->null && *soap->href != '#')
03848 { soap_revert(soap);
03849 if (!(*a = soap_in_ns1__CrossID(soap, tag, *a, type)))
03850 return NULL;
03851 }
03852 else
03853 { a = (struct ns1__CrossID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__CrossID, sizeof(struct ns1__CrossID), 0);
03854 if (soap->body && soap_element_end_in(soap, tag))
03855 return NULL;
03856 }
03857 return a;
03858 }
03859
03860 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__ArrayOfMoreData(struct soap *soap, struct ns1__ArrayOfMoreData *const*a)
03861 {
03862 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__ArrayOfMoreData))
03863 soap_serialize_ns1__ArrayOfMoreData(soap, *a);
03864 }
03865
03866 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__ArrayOfMoreData(struct soap *soap, struct ns1__ArrayOfMoreData *const*a, const char *tag, const char *type)
03867 {
03868 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__ArrayOfMoreData);
03869 if (soap_out_PointerTons1__ArrayOfMoreData(soap, tag, id, a, type))
03870 return soap->error;
03871 return soap_putindependent(soap);
03872 }
03873
03874 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__ArrayOfMoreData(struct soap *soap, const char *tag, int id, struct ns1__ArrayOfMoreData *const*a, const char *type)
03875 {
03876 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__ArrayOfMoreData);
03877 if (id < 0)
03878 return soap->error;
03879 return soap_out_ns1__ArrayOfMoreData(soap, tag, id, *a, type);
03880 }
03881
03882 SOAP_FMAC3 struct ns1__ArrayOfMoreData ** SOAP_FMAC4 soap_get_PointerTons1__ArrayOfMoreData(struct soap *soap, struct ns1__ArrayOfMoreData **p, const char *tag, const char *type)
03883 {
03884 if ((p = soap_in_PointerTons1__ArrayOfMoreData(soap, tag, p, type)))
03885 if (soap_getindependent(soap))
03886 return NULL;
03887 return p;
03888 }
03889
03890 SOAP_FMAC3 struct ns1__ArrayOfMoreData ** SOAP_FMAC4 soap_in_PointerTons1__ArrayOfMoreData(struct soap *soap, const char *tag, struct ns1__ArrayOfMoreData **a, const char *type)
03891 {
03892 if (soap_element_begin_in(soap, tag, 1, NULL))
03893 return NULL;
03894 if (!a)
03895 if (!(a = (struct ns1__ArrayOfMoreData **)soap_malloc(soap, sizeof(struct ns1__ArrayOfMoreData *))))
03896 return NULL;
03897 *a = NULL;
03898 if (!soap->null && *soap->href != '#')
03899 { soap_revert(soap);
03900 if (!(*a = soap_in_ns1__ArrayOfMoreData(soap, tag, *a, type)))
03901 return NULL;
03902 }
03903 else
03904 { a = (struct ns1__ArrayOfMoreData **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__ArrayOfMoreData, sizeof(struct ns1__ArrayOfMoreData), 0);
03905 if (soap->body && soap_element_end_in(soap, tag))
03906 return NULL;
03907 }
03908 return a;
03909 }
03910
03911 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons1__ArrayOfCrossID(struct soap *soap, struct ns1__ArrayOfCrossID *const*a)
03912 {
03913 if (!soap_reference(soap, *a, SOAP_TYPE_ns1__ArrayOfCrossID))
03914 soap_serialize_ns1__ArrayOfCrossID(soap, *a);
03915 }
03916
03917 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons1__ArrayOfCrossID(struct soap *soap, struct ns1__ArrayOfCrossID *const*a, const char *tag, const char *type)
03918 {
03919 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTons1__ArrayOfCrossID);
03920 if (soap_out_PointerTons1__ArrayOfCrossID(soap, tag, id, a, type))
03921 return soap->error;
03922 return soap_putindependent(soap);
03923 }
03924
03925 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons1__ArrayOfCrossID(struct soap *soap, const char *tag, int id, struct ns1__ArrayOfCrossID *const*a, const char *type)
03926 {
03927 id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns1__ArrayOfCrossID);
03928 if (id < 0)
03929 return soap->error;
03930 return soap_out_ns1__ArrayOfCrossID(soap, tag, id, *a, type);
03931 }
03932
03933 SOAP_FMAC3 struct ns1__ArrayOfCrossID ** SOAP_FMAC4 soap_get_PointerTons1__ArrayOfCrossID(struct soap *soap, struct ns1__ArrayOfCrossID **p, const char *tag, const char *type)
03934 {
03935 if ((p = soap_in_PointerTons1__ArrayOfCrossID(soap, tag, p, type)))
03936 if (soap_getindependent(soap))
03937 return NULL;
03938 return p;
03939 }
03940
03941 SOAP_FMAC3 struct ns1__ArrayOfCrossID ** SOAP_FMAC4 soap_in_PointerTons1__ArrayOfCrossID(struct soap *soap, const char *tag, struct ns1__ArrayOfCrossID **a, const char *type)
03942 {
03943 if (soap_element_begin_in(soap, tag, 1, NULL))
03944 return NULL;
03945 if (!a)
03946 if (!(a = (struct ns1__ArrayOfCrossID **)soap_malloc(soap, sizeof(struct ns1__ArrayOfCrossID *))))
03947 return NULL;
03948 *a = NULL;
03949 if (!soap->null && *soap->href != '#')
03950 { soap_revert(soap);
03951 if (!(*a = soap_in_ns1__ArrayOfCrossID(soap, tag, *a, type)))
03952 return NULL;
03953 }
03954 else
03955 { a = (struct ns1__ArrayOfCrossID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns1__ArrayOfCrossID, sizeof(struct ns1__ArrayOfCrossID), 0);
03956 if (soap->body && soap_element_end_in(soap, tag))
03957 return NULL;
03958 }
03959 return a;
03960 }
03961
03962 SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap *soap, char **a)
03963 { soap_default_string(soap, a);
03964 }
03965
03966 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a)
03967 { soap_serialize_string(soap, a);
03968 }
03969
03970 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
03971 {
03972 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
03973 if (soap_out__QName(soap, tag, id, a, type))
03974 return soap->error;
03975 return soap_putindependent(soap);
03976 }
03977
03978 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
03979 {
03980 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
03981 }
03982
03983 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
03984 {
03985 if ((p = soap_in__QName(soap, tag, p, type)))
03986 if (soap_getindependent(soap))
03987 return NULL;
03988 return p;
03989 }
03990
03991 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
03992 {
03993 return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1);
03994 }
03995
03996 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
03997 { (void)soap;
03998 #ifdef SOAP_DEFAULT_string
03999 *a = SOAP_DEFAULT_string;
04000 #else
04001 *a = (char *)0;
04002 #endif
04003 }
04004
04005 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
04006 {
04007 soap_reference(soap, *a, SOAP_TYPE_string);
04008 }
04009
04010 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
04011 {
04012 register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
04013 if (soap_out_string(soap, tag, id, a, type))
04014 return soap->error;
04015 return soap_putindependent(soap);
04016 }
04017
04018 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
04019 {
04020 return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
04021 }
04022
04023 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
04024 {
04025 if ((p = soap_in_string(soap, tag, p, type)))
04026 if (soap_getindependent(soap))
04027 return NULL;
04028 return p;
04029 }
04030
04031 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
04032 {
04033 return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1);
04034 }
04035
04036 #ifdef __cplusplus
04037 }
04038 #endif
04039
04040